From 3005d8d8f915921cc1eaafaf7fde450b10c32d9c Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 12:42:56 -0700 Subject: [PATCH 01/39] renamed main module to be 1D; started 2D module --- brainiak/reconstruct/iem.py | 538 ++++++++++++++++++++++++++++++++---- 1 file changed, 487 insertions(+), 51 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 6e89d7bb8..be7eab8a2 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -49,28 +49,24 @@ from sklearn.base import BaseEstimator from ..utils.utils import circ_dist -__all__ = [ - "InvertedEncoding", -] +__all__ = ["InvertedEncoding1D", ] logger = logging.getLogger(__name__) MAX_CONDITION_CHECK = 9000 -class InvertedEncoding(BaseEstimator): +class InvertedEncoding1D(BaseEstimator): """Basis function-based reconstruction method - Inverted encoding models (alternatively known as forward - models) are used to reconstruct a feature, e.g. color of - a stimulus, from patterns across voxels in functional - data. The model uses n_channels number of idealized - basis functions and assumes that the transformation from - stimulus feature (e.g. color) to basis function is one- - to-one and invertible. The response of a voxel is - expressed as the weighted sum of basis functions. - In this implementation, basis functions were half-wave - rectified sinusoid functions raised to a power set by - the user (e.g. 6). + Inverted encoding models (alternatively known as forward models) are used + to reconstruct a feature represented in a 1-dimensional (1D) space, + e.g. color of a stimulus, from patterns across voxels in functional data. + The model uses n_channels number of idealized basis functions and assumes + that the transformation from stimulus feature (e.g. color) to basis + function is one- to-one and invertible. The response of a voxel is + expressed as the weighted sum of basis functions. In this implementation, + basis functions were half-wave rectified sinusoid functions raised to a + power set by the user (e.g. 6). The model: Inverted encoding models reconstruct a stimulus feature from @@ -97,7 +93,7 @@ class InvertedEncoding(BaseEstimator): (3) C_est = inv(W_est)*B_exp - Given estimated channel responses, C_est, it is straighforward + Given estimated channel responses, C_est, it is straightforward to obtain the reconstructed feature value by summing over channels multiplied by their channel responses and taking the argmax (i.e. the feature associated with the maximum value). @@ -160,17 +156,17 @@ class InvertedEncoding(BaseEstimator): relates estimated channel responses to response amplitude data """ + def __init__(self, n_channels=6, channel_exp=5, - stimulus_mode='halfcircular', range_start=0., - range_stop=180., channel_density=180, - stimulus_resolution=None): + stimulus_mode='halfcircular', range_start=0., range_stop=180., + channel_density=180, stimulus_resolution=None): self.n_channels = n_channels self.channel_exp = channel_exp self.stimulus_mode = stimulus_mode self.range_start = range_start self.range_stop = range_stop self.channel_density = channel_density - self.channel_domain = np.linspace(range_start, range_stop-1, + self.channel_domain = np.linspace(range_start, range_stop - 1, channel_density) if stimulus_resolution is None: self.stim_res = channel_density @@ -187,18 +183,17 @@ def _check_params(self): if (self.range_stop - self.range_start) != 180.: raise ValueError("For half-circular feature spaces," "the range must be 180 degrees, " - "not {}".format(self.range_stop - - self.range_start)) + "not {}".format( + self.range_stop - self.range_start)) elif self.stimulus_mode == 'circular': if (self.range_stop - self.range_start) != 360.: raise ValueError("For circular feature spaces, the" " range must be 360 degrees" - "not {}".format(self.range_stop - - self.range_start)) + "not {}".format( + self.range_stop - self.range_start)) if self.n_channels < 2: raise ValueError("Insufficient number of channels.") - if not np.isin(self.stimulus_mode, ['circular', - 'halfcircular']): + if not np.isin(self.stimulus_mode, ['circular', 'halfcircular']): raise ValueError("Stimulus mode must be one of these: " "'circular', 'halfcircular'") @@ -230,13 +225,12 @@ def fit(self, X, y): "dimensions.") else: if shape_data[0] != shape_labels[0]: - raise ValueError( - "Mismatched data samples and label samples") + raise ValueError("Mismatched data samples and label samples") # Define the channels (or basis set) self.channels_, channel_centers = self._define_channels() - logger.info("Defined channels centered at {} degrees." - .format(np.rad2deg(channel_centers))) + logger.info("Defined channels centered at {} degrees.".format( + np.rad2deg(channel_centers))) # Create a matrix of channel activations for every observation. # (i.e., C1 in Brouwer & Heeger 2009.) C = self._define_trial_activations(y) @@ -292,11 +286,11 @@ def score(self, X, y): pred_features = pred_features * 2 y = y * 2 - ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features))**2).sum() + ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features)) ** 2).sum() sstot = (circ_dist(np.deg2rad(y), - np.ones(y.size)*scipy.stats.circmean(np.deg2rad(y)) - ) ** 2).sum() - score_value = (1 - ssres/sstot) + np.ones(y.size) * scipy.stats.circmean( + np.deg2rad(y))) ** 2).sum() + score_value = (1 - ssres / sstot) return score_value @@ -307,13 +301,11 @@ def get_params(self): ------- params: parameter of this object """ - return{"n_channels": self.n_channels, - "channel_exp": self.channel_exp, - "stimulus_mode": self.stimulus_mode, - "range_start": self.range_start, - "range_stop": self.range_stop, - "channel_domain": self.channel_domain, - "stim_res": self.stim_res} + return {"n_channels": self.n_channels, "channel_exp": self.channel_exp, + "stimulus_mode": self.stimulus_mode, + "range_start": self.range_start, "range_stop": self.range_stop, + "channel_domain": self.channel_domain, + "stim_res": self.stim_res} def set_params(self, **parameters): """Sets model parameters after initialization. @@ -353,9 +345,9 @@ def _define_channels(self): centers = channel_centers # define exponentiated function - channels = np.asarray([np.cos(np.deg2rad(domain) - cx) ** - self.channel_exp - for cx in centers]) + channels = np.asarray( + [np.cos(np.deg2rad(domain) - cx) ** self.channel_exp for cx in + centers]) # half-wave rectification preserving circularity channels = abs(channels) @@ -375,7 +367,452 @@ def _define_trial_activations(self, stimuli): C: matrix of predicted channel responses. dimensions are number of observations by stimulus resolution """ - stim_axis = np.linspace(self.range_start, self.range_stop-1, + stim_axis = np.linspace(self.range_start, self.range_stop - 1, + self.stim_res) + if self.range_start > 0: + stimuli = stimuli + self.range_start + elif self.range_start < 0: + stimuli = stimuli - self.range_start + one_hot = np.eye(self.stim_res) + indices = [np.argmin(abs(stim_axis - x)) for x in stimuli] + stimulus_mask = one_hot[indices, :] + if self.channel_density != self.stim_res: + if self.channel_density % self.stim_res == 0: + stimulus_mask = np.repeat(stimulus_mask, + self.channel_density / self.stim_res) + else: + raise NotImplementedError("This code doesn't currently support" + " stimuli which are not square " + "functions in the feature domain, or" + " stimulus widths that are not even" + "divisors of the number of points in" + " the feature domain.") + + C = stimulus_mask @ self.channels_.transpose() + # Check that C is full rank + if np.linalg.matrix_rank(C) < self.n_channels: + warnings.warn("Stimulus matrix is {}, not full rank. May cause " + "issues with stimulus prediction/reconstruction.".format( + np.linalg.matrix_rank(C)), RuntimeWarning) + return C + + def _predict_channel_responses(self, X): + """Computes predicted channel responses from data + (e.g. C2 in Brouwer & Heeger 2009) + + Parameters + ---------- + X: numpy data matrix. [observations, voxels] + + Returns + ------- + channel_response: numpy matrix of channel responses + """ + channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose()) + return channel_response + + def _predict_feature_responses(self, X): + """Takes channel weights and transforms them into continuous + functions defined in the feature domain. + + Parameters + --------- + X: numpy matrix of data. [observations, voxels] + + Returns + ------- + pred_response: predict response from all channels. Used + to predict feature (e.g. direction). + """ + pred_response = np.matmul(self.channels_.transpose(), + self._predict_channel_responses(X)) + return pred_response + + def _predict_features(self, X): + """Predicts feature value (e.g. direction) from data in X. + Takes the maximum of the 'reconstructed' or predicted response + function. + + Parameters + --------- + X: numpy matrix of data. [observations, voxels] + + Returns + ------- + pred_features: predicted feature from response across all + channels. + """ + pred_response = self._predict_feature_responses(X) + feature_ind = np.argmax(pred_response, 0) + pred_features = self.channel_domain[feature_ind] + + return pred_features + + +class InvertedEncoding2D(BaseEstimator): + """Basis function-based reconstruction method + + Inverted encoding models (alternatively known as forward models) are used + to reconstruct a feature represented in a 2-dimensional (2D) space, + e.g. position on a projector screen, from patterns across voxels in + functional data. The model uses some number of idealized basis functions + that cover the 2D space, and assumes that the transformation from + stimulus feature (e.g. 2D spatial position) to basis function is one- + to-one and invertible. The response of a voxel is expressed as the + weighted sum of basis functions. In this implementation, basis functions + were half-wave rectified sinusoid functions raised to some power (set by the + user). + + The documentation will refer to the 'stimulus space' or 'stimulus domain', + which should be a 2D space in consistent units (e.g. pixels, or degrees + visual angle). + + The model: + Inverted encoding models reconstruct a stimulus feature from + patterns of BOLD activity by relating the activity in each + voxel, B, to the values of hypothetical channels (or basis + functions), C, according to Equation 1 below. + + (1) B = W*C + + where W is a weight matrix that represents the relationship + between BOLD activity and Channels. W must be estimated from + training data; this implementation (and most described in the + literature) uses linear regression to estimate W as in Equation + 2 below [note: inv() represents matrix inverse or + pseudo-inverse]. + + (2) W_est = B_train*inv(C_train) + + The weights in W_est (short for "estimated") represent the + contributions of each channel to the response of each voxel. + Estimated channel responses can be computed given W_est and + new voxel activity represented in matrix B_exp (short for + "experiment") through inversion of Equation 1: + + (3) C_est = inv(W_est)*B_exp + + Given estimated channel responses, C_est, it is straightforward + to obtain the reconstructed feature value by summing over + channels multiplied by their channel responses and taking the + argmax (i.e. the feature associated with the maximum value). + + Using this model: + Use fit() to estimate the weights of the basis functions given + input data (e.g. beta values from fMRI data). This function + will execute equation 2 above. + + Use predict() to compute predicted stimulus values + from new functional data. This function computes estimated + channel responses, as in equation 3, then computes summed + channel output and finds the argmax (within the stimulus + feature space) associated with those responses. + + Use score() to compute a measure of the error of the prediction + based on known stimuli. + + Parameters + ---------- + n_channels: int, default 5. Number of channels + The number of channels, or basis functions, to be used in + the inverted encoding model. + + channel_exp: int, default 6. Basis function exponent. + The exponent of the sinuoidal basis functions, which + establishes the width of the functions. + + stimulus_resolution: double, default None will set the stimulus + resolution to be identical to the channel density. This sets + the resolution at which the stimuli were presented (e.g. a + spatial position with some width has a lower stimulus + resolution). + + Attributes + ---------- + channels_: [n_channels, channel density] NumPy 2D array + matrix defining channel values + + W_: sklearn.linear_model model containing weight matrix that + relates estimated channel responses to response amplitude + data + """ + + def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, + channels=None): + # n_channels, stim_xlim, stim_ylim, stimulus_resolution, + # chan_xlim, chan_ylim, channel_exp=5, + # channel_arrangement='square'): + # Automatically expand n_channels or stimulus_resolution if only one + # value is given. This will create a square basis set or square field + # of view (FOV) for the reconstruction. + # if not isinstance(n_channels, list): # make basis set square + # n_channels = [n_channels, n_channels] + if not isinstance(stimulus_resolution, list): # make FOV square + stimulus_resolution = [stimulus_resolution, stimulus_resolution] + self.stim_fov = [stim_xlim, stim_ylim] + self.stim_pixels = [np.linspace(stim_xlim[0], stim_xlim[1], + stimulus_resolution[0]), + np.linspace(stim_ylim[0], stim_ylim[1], + stimulus_resolution[1])] + self.channels = channels + # self.channel_limits = [chan_xlim, chan_ylim] + self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) + # self.n_channels = n_channels + # self.channel_exp = channel_exp + # self.channel_arrangement = channel_arrangement + # self._check_params() + # + # def _check_params(self): + # if any(self.n_channels < 2): + # raise ValueError("Insufficient number of channels.") + # if not np.isin(self.stimulus_mode, ['circular', 'halfcircular']): + # raise ValueError("Stimulus mode must be one of these: " + # "'circular', 'halfcircular'") + + def fit(self, X, y): + """Use data and feature variable labels to fit an IEM + + Parameters + ---------- + X: numpy matrix of voxel activation data. [observations, voxels] + Should contain the beta values for each observation or + trial and each voxel of training data. + y: numpy array of response variable. [observations] + Should contain the feature for each observation in X. + """ + # Check that data matrix is well conditioned: + if np.linalg.cond(X) > MAX_CONDITION_CHECK: + logger.error("Data is singular.") + raise ValueError("Data matrix is nearly singular.") + if self.channels is None: + raise ValueError("Must define channels (set of basis functions).") + if X.shape[0] < self.n_channels: + logger.error("Not enough observations. Cannot calculate " + "pseudoinverse.") + raise ValueError("Fewer observations (trials) than " + "channels. Cannot compute pseudoinverse.") + # Check that the data matrix is the right size + shape_data = np.shape(X) + shape_labels = np.shape(y) + if len(shape_data) != 2: + raise ValueError("Data matrix has too many or too few " + "dimensions.") + else: + if shape_data[0] != shape_labels[0]: + raise ValueError("Mismatched data samples and label samples") + + # # Define the channels (or basis set) + # self.channels_, channel_centers = self._define_channels() + # logger.info("Defined channels centered at {} degrees.".format( + # np.rad2deg(channel_centers))) + # Create a matrix of channel activations for every observation. + # (i.e., C1 in Brouwer & Heeger 2009.) + C = self._define_trial_activations(y) + # Solve for W in B = WC + self.W_ = X.transpose() @ np.linalg.pinv(C.transpose()) + if np.linalg.cond(self.W_) > MAX_CONDITION_CHECK: + logger.error("Weight matrix is nearly singular.") + raise ValueError("Weight matrix is nearly singular.") + + return self + + def predict(self, X): + """Use test data to predict the feature + + Parameters + ---------- + X: numpy matrix of voxel activation from test trials + [observations, voxels]. Used to predict feature + associated with the given observation. + + Returns + ------- + model_prediction: numpy array of estimated feature values. + """ + # Check that the data matrix is the right size + shape_data = np.shape(X) + if len(shape_data) != 2: + raise ValueError("Data matrix has too many or too few " + "dimensions.") + + model_prediction = self._predict_features(X) + + return model_prediction + + def score(self, X, y): + """Calculate error measure of prediction. Default measurement + is R^2, the coefficient of determination. + + Parameters + ---------- + X: numpy matrix of voxel activation from new data + [observations,voxels] + y: numpy array of responses. [observations] + + Returns + ------- + score_value: the error measurement between the actual + feature and predicted features. + """ + pred_features = self.predict(X) + if self.stimulus_mode == 'halfcircular': + # multiply features by 2. otherwise doesn't wrap properly + pred_features = pred_features * 2 + y = y * 2 + # TODO: replace this with a version for 2D space + ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features)) ** 2).sum() + sstot = (circ_dist(np.deg2rad(y), + np.ones(y.size) * scipy.stats.circmean( + np.deg2rad(y))) ** 2).sum() + score_value = (1 - ssres / sstot) + + return score_value + + def get_params(self): + """Returns model parameters. + + Returns + ------- + params: parameter of this object + """ + return {"n_channels": self.n_channels, "channel_exp": self.channel_exp, + "stimulus_mode": self.stimulus_mode, + "range_start": self.range_start, "range_stop": self.range_stop, + "channel_domain": self.channel_domain, + "stim_res": self.stim_res} + + def set_params(self, **parameters): + """Sets model parameters after initialization. + + Parameters + ---------- + parameters: structure with parameters and change values + """ + for parameter, value in parameters.items(): + setattr(self, parameter, value) + + setattr(self, "channel_domain", + np.linspace(self.range_start, self.range_stop - 1, + self.channel_density)) + self._check_params() + return self + + def _make_2d_cosine(self, x, y, x_center, y_center, r): + # x, y is a meshgrid of x, y values at which to compute the 2d cos + # x_center, y_center is the center of the function + # r is the distance from center to 0 (T/2) - function will go from z = 0 to + # 0 across 2*r at widest point + z = [None] * len(x_center) + for i in range(len(x_center)): + myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2) #** 0.5 + qq = (myr <= r) * 1 + zp = ((0.5 * (1 + np.cos(myr * np.pi / r))) ** self.channel_exp) + z[i] = zp * qq + return z + + # def _calc_2d_cosine_fwhm(self, size_constant): + # fwhm = size_constant \ + # * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi + # return fwhm + + def _2d_cosine_fwhm_to_cossz(self, fwhm): + cossz = (np.pi * fwhm) / \ + (np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5)) + return cossz + + def define_basis_functions_sqgrid(self, nx, ny, channel_size=None): + """Define basis functions (aka channels) arrange in a square grid. + Sets the self.channels parameter. + + Parameters + ---------- + nx: number of channels in the x (horizontal) direction + ny: number of channels in the y (vertical) direction + channel_size: the desired full-width half-maximum (FWHM) of the + channel, in stimulus space. + + Returns + ------- + channel_centers: numpy array of the centers of each channel + """ + chan_xcenters = np.linspace(self.channel_limits[0][0], + self.channel_limits[0][1], nx) + chan_ycenters = np.linspace(self.channel_limits[1][0], + self.channel_limits[1][1], ny) + if channel_size is None: + # To get even coverage, setting the channel FWHM to ~1.1x the + # spacing between the channels works. (See Sprague et al. 2013 + # Methods & Supplementary Figure 3). + channel_size = 1.1*(chan_xcenters[1] - chan_xcenters[0]) + cos_width = self._2d_cosine_fwhm_to_radians(channel_size) + # define exponentiated function + self.channels = np.asarray( + self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), + chan_xcenters, chan_ycenters, + cos_width)) + self.n_channels = self.channels.size + + return self.channels + + def define_basis_functions_trigrid(self, channel_size, grid_radius): + """Define basis functions (aka channels) arranged in a triangular grid. + + Returns + ------- + channel_centers: numpy array of the centers of each channel + """ + x_dist = np.diff(self.channel_limits[0]) / (grid_radius*2) + y_dist = x_dist * np.sqrt(3) * 0.5 + trigrid = np.zeros((0, 2)) + xbase = np.expand_dims(np.arange(self.channel_limits[0][0], + self.channel_limits[0][1], + x_dist), 1) + for yi, y in enumerate(np.arange(self.channel_limits[1][0], + self.channel_limits[1][1], y_dist)): + if (yi % 2) == 0: + xx = xbase.copy() + yy = np.ones((xx.size, 1)) * y + else: + xx = xbase.copy() + x_dist / 2 + yy = np.ones((xx.size, 1)) * y + trigrid = np.vstack( + (trigrid, np.hstack((xx, yy)))) + + if channel_size is None: + # To get even coverage, setting the channel FWHM to ~1.1x the + # spacing between the channels works. (See Sprague et al. 2013 + # Methods & Supplementary Figure 3). + channel_size = 1.1*x_dist + cos_width = self._2d_cosine_fwhm_to_radians(channel_size) + result = np.asarray(self._make_2d_cosine(self.xp.reshape(-1, 1), + self.yp.reshape(-1, 1), + trigrid[:, 0], trigrid[:, 1], + cos_width)) + self.channels = result + self.n_channels = result.size + + return self.channels + + + def _define_trial_activations(self, stimuli): + """Defines a numpy matrix of predicted channel responses for + each trial/observation. + + Parameters + + stimuli: numpy array of the feature values for each + observation (e.g., [0, 5, 15, 30, ...] degrees) + + Returns + ------- + C: matrix of predicted channel responses. dimensions are + number of observations by stimulus resolution + """ + # self.stim_xdomain = np.linspace(stim_fov[0][0], stim_fov[0][1], + # stimulus_resolution[0]) + # self.stim_ydomain = np.linspace(stim_fov[1][0], stim_fov[1][1], + # stimulus_resolution[1]) + stim_axis = np.linspace(self.range_start, self.range_stop - 1, self.stim_res) if self.range_start > 0: stimuli = stimuli + self.range_start @@ -386,8 +823,8 @@ def _define_trial_activations(self, stimuli): stimulus_mask = one_hot[indices, :] if self.channel_density != self.stim_res: if self.channel_density % self.stim_res == 0: - stimulus_mask = np.repeat(stimulus_mask, self.channel_density / - self.stim_res) + stimulus_mask = np.repeat(stimulus_mask, + self.channel_density / self.stim_res) else: raise NotImplementedError("This code doesn't currently support" " stimuli which are not square " @@ -400,8 +837,8 @@ def _define_trial_activations(self, stimuli): # Check that C is full rank if np.linalg.matrix_rank(C) < self.n_channels: warnings.warn("Stimulus matrix is {}, not full rank. May cause " - "issues with stimulus prediction/reconstruction." - .format(np.linalg.matrix_rank(C)), RuntimeWarning) + "issues with stimulus prediction/reconstruction.".format( + np.linalg.matrix_rank(C)), RuntimeWarning) return C def _predict_channel_responses(self, X): @@ -416,8 +853,7 @@ def _predict_channel_responses(self, X): ------- channel_response: numpy matrix of channel responses """ - channel_response = np.matmul(np.linalg.pinv(self.W_), - X.transpose()) + channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose()) return channel_response def _predict_feature_responses(self, X): From a8f8dba893de9f0799aecda42aa4af0d9729fd40 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 12:43:27 -0700 Subject: [PATCH 02/39] finish refactoring for renamed 1D IEM --- .../iem_example_synthetic_RF_data.ipynb | 6 +- tests/reconstruct/test_iem.py | 72 +++++++++---------- 2 files changed, 39 insertions(+), 39 deletions(-) diff --git a/examples/reconstruct/iem_example_synthetic_RF_data.ipynb b/examples/reconstruct/iem_example_synthetic_RF_data.ipynb index 95c43f09c..4c7236207 100644 --- a/examples/reconstruct/iem_example_synthetic_RF_data.ipynb +++ b/examples/reconstruct/iem_example_synthetic_RF_data.ipynb @@ -33,13 +33,13 @@ "\n", "range_stop = 360\n", "feature_resolution = 360\n", - "iem_obj = IEM.InvertedEncoding(n_channels, cos_exponent, stimulus_mode='circular', range_start=range_start, \n", + "iem_obj = IEM.InvertedEncoding1D(n_channels, cos_exponent, stimulus_mode='circular', range_start=range_start, \n", " range_stop=range_stop, channel_density=feature_resolution)\n", "\n", "# You can also try the half-circular space. Here's the associated code:\n", "# range_stop = 180 # since 0 and 360 degrees are the same, we want to stop shy of 360\n", "# feature_resolution = 180\n", - "# iem_obj = IEM.InvertedEncoding(n_channels, cos_exponent, stimulus_mode='halfcircular', range_start=range_start, \n", + "# iem_obj = IEM.InvertedEncoding1D(n_channels, cos_exponent, stimulus_mode='halfcircular', range_start=range_start, \n", "# range_stop=range_stop, channel_density=feature_resolution, verbose=True)\n", "\n", "stim_vals = np.linspace(0, feature_resolution - (feature_resolution/6), 6).astype(int)" @@ -204,7 +204,7 @@ { "data": { "text/plain": [ - "InvertedEncoding(channel_exp=5, n_channels=6, range_start=0, range_stop=360)" + "InvertedEncoding1D(channel_exp=5, n_channels=6, range_start=0, range_stop=360)" ] }, "execution_count": 5, diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 4370dc827..521a9a6ae 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -15,7 +15,7 @@ import pytest import numpy as np import logging -from brainiak.reconstruct.iem import InvertedEncoding +from brainiak.reconstruct.iem import InvertedEncoding1D from brainiak.utils.fmrisim import generate_1d_gaussian_rfs, \ generate_1d_rf_responses from scipy.stats import circmean @@ -25,56 +25,56 @@ # Simple test: can an instance be instantiated? def test_can_instantiate(): - s = InvertedEncoding() - assert s, "Invalid InvertedEncoding instance" + s = InvertedEncoding1D() + assert s, "Invalid InvertedEncoding1D instance" # Simple test for checking range values. def test_instantiate_improper_range(): with pytest.raises(ValueError): - s = InvertedEncoding(6, 5, 'halfcircular', range_start=20, - range_stop=0) - assert s, "Invalid InvertedEncoding instance" + s = InvertedEncoding1D(6, 5, 'halfcircular', range_start=20, + range_stop=0) + assert s, "Invalid InvertedEncoding1D instance" # Test to check stimulus resolution input def test_stimulus_resolution(): - s = InvertedEncoding(6, 5, stimulus_resolution=360) + s = InvertedEncoding1D(6, 5, stimulus_resolution=360) assert s.stim_res == 360 # Provide invalid data so that channels cannot be created. def test_cannot_instantiate_channels(): with pytest.raises(ValueError): - s = InvertedEncoding(n_channels=0) - assert s, "Invalid InvertedEncoding instance" + s = InvertedEncoding1D(n_channels=0) + assert s, "Invalid InvertedEncoding1D instance" # Provide invalid stimulus mode def test_stimulus_mode(): with pytest.raises(ValueError): - s = InvertedEncoding(6, 5, 'random') - assert s, "Invalid InvertedEncoding instance" + s = InvertedEncoding1D(6, 5, 'random') + assert s, "Invalid InvertedEncoding1D instance" # Provide mismatching range and stimulus_mode input def test_range_stimulus_mode_circ(): with pytest.raises(ValueError): - s = InvertedEncoding(6, 5, 'circular', 0, 180) - assert s, "Invalid InvertedEncoding instance" + s = InvertedEncoding1D(6, 5, 'circular', 0, 180) + assert s, "Invalid InvertedEncoding1D instance" # Provide mismatching range & stimulus mode, with half circular def test_range_stimulus_mode_halfcirc(): with pytest.raises(ValueError): - s = InvertedEncoding(6, 5, 'halfcircular', -10, 350) - assert s, "Invalid InvertedEncoding instance" + s = InvertedEncoding1D(6, 5, 'halfcircular', -10, 350) + assert s, "Invalid InvertedEncoding1D instance" # Test for n_observations < n_channels def test_data_amount(): x = np.random.rand(5, 1000) - s = InvertedEncoding() + s = InvertedEncoding1D() with pytest.raises(ValueError): s.fit(x, np.random.rand(5)) assert s, "Invalid data" @@ -83,7 +83,7 @@ def test_data_amount(): # Test number of data dimensions def test_data_dimensions(): x = np.random.rand(5, 10, 2) - s = InvertedEncoding() + s = InvertedEncoding1D() with pytest.raises(ValueError): s.fit(x, np.random.rand(5)) @@ -102,13 +102,13 @@ def test_data_dimensions(): # Test if valid data can be fit. def test_can_fit_data(): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y) # Test if valid data can be fit in circular space. def test_can_fit_circular_space(): - s = InvertedEncoding(6, 5, 'circular', range_stop=360) + s = InvertedEncoding1D(6, 5, 'circular', range_stop=360) s.fit(X, y) @@ -116,12 +116,12 @@ def test_can_fit_circular_space(): # algorithm. def test_cannot_fit_data(): with pytest.raises(ValueError): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X.transpose(), y) def test_ill_conditioned_train_data(): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() with pytest.raises(ValueError): X = np.array([[0, 0, 0], [1, 1, 1]]) Invt_model.fit(X, np.array([0, 0, 0])) @@ -132,20 +132,20 @@ def test_extra_data_dimensions(): with pytest.raises(ValueError): n, dim1, dim2 = 300, 3, 3 X = np.random.rand(n//3, dim1, dim2) - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y) # Test case when # of observations are not matched btwn data & labels def test_mismatched_observations(): with pytest.raises(ValueError): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y[:-50]) # Test prediction capability from valid (fabricated) data def test_can_predict_from_data(): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y) m_reconstruct = [] for j in np.arange(dim): @@ -157,7 +157,7 @@ def test_can_predict_from_data(): # Show that prediction is invalid when input data is wrong size def test_cannot_predict_from_data(): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y) with pytest.raises(ValueError): _ = Invt_model.predict(X2[0:n_, :].transpose()) @@ -165,7 +165,7 @@ def test_cannot_predict_from_data(): # Show proper scoring function with valid (fabricated) test data def test_can_score(): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y) score = Invt_model.score(X2, y) logger.info('Scores: ' + str(score)) @@ -174,7 +174,7 @@ def test_can_score(): # Test scoring with invalid data formatting def test_cannot_score(): with pytest.raises(ValueError): - Invt_model = InvertedEncoding() + Invt_model = InvertedEncoding1D() Invt_model.fit(X, y) score = Invt_model.score(X2.transpose(), y) logger.info('Scores: ' + str(score)) @@ -182,16 +182,16 @@ def test_cannot_score(): # Test stimulus resolution that is not even multiple def test_stimulus_resolution_odd(): - Invt_model = InvertedEncoding(stimulus_resolution=59) + Invt_model = InvertedEncoding1D(stimulus_resolution=59) with pytest.raises(NotImplementedError): Invt_model.fit(X, y) # Test stimulus masking def test_stimulus_mask(): - Invt_model = InvertedEncoding(6, 5, range_start=-10, - range_stop=170, - stimulus_resolution=60) + Invt_model = InvertedEncoding1D(6, 5, range_start=-10, + range_stop=170, + stimulus_resolution=60) chans, _ = Invt_model._define_channels() Invt_model.set_params(channels_=chans) with pytest.warns(RuntimeWarning): @@ -202,9 +202,9 @@ def test_stimulus_mask(): # Test stimulus masking with different range def test_stimulus_mask_shift_positive(): - Invt_model = InvertedEncoding(6, 5, range_start=10, - range_stop=190, - stimulus_resolution=60) + Invt_model = InvertedEncoding1D(6, 5, range_start=10, + range_stop=190, + stimulus_resolution=60) chans, _ = Invt_model._define_channels() Invt_model.set_params(channels_=chans) with pytest.warns(RuntimeWarning): @@ -215,7 +215,7 @@ def test_stimulus_mask_shift_positive(): # Test ability to get model parameters from object def test_can_get_params(): - s = InvertedEncoding() + s = InvertedEncoding1D() param_out = s.get_params() logger.info('Returned Parameters: ' + str(param_out.get('n_channels')) + @@ -225,7 +225,7 @@ def test_can_get_params(): # Test ability to set model parameters of an object instance def test_can_set_params(): - s = InvertedEncoding() + s = InvertedEncoding1D() s.set_params(n_channels=10, stimulus_mode='circular', range_start=-90, From 9a407f3e29cc7c27ace584b33f1c9ca568998cc8 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 16:42:20 -0700 Subject: [PATCH 03/39] adding channel_limits to init input --- brainiak/reconstruct/iem.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index be7eab8a2..df4be76f6 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -538,7 +538,7 @@ class InvertedEncoding2D(BaseEstimator): """ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, - channels=None): + chan_xlim, chan_ylim, channels=None): # n_channels, stim_xlim, stim_ylim, stimulus_resolution, # chan_xlim, chan_ylim, channel_exp=5, # channel_arrangement='square'): @@ -555,7 +555,7 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, np.linspace(stim_ylim[0], stim_ylim[1], stimulus_resolution[1])] self.channels = channels - # self.channel_limits = [chan_xlim, chan_ylim] + self.channel_limits = [chan_xlim, chan_ylim] self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) # self.n_channels = n_channels # self.channel_exp = channel_exp From 414abdbf979b7ed0ba61c0c07c3e00349d0625e1 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 17:44:38 -0700 Subject: [PATCH 04/39] updated _define_trial_activations to create 2D stimulus mask (assuming circular stimuli) --- brainiak/reconstruct/iem.py | 37 ++++++++++--------------------------- 1 file changed, 10 insertions(+), 27 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index df4be76f6..38c462c1c 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -537,7 +537,7 @@ class InvertedEncoding2D(BaseEstimator): data """ - def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, + def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius, chan_xlim, chan_ylim, channels=None): # n_channels, stim_xlim, stim_ylim, stimulus_resolution, # chan_xlim, chan_ylim, channel_exp=5, @@ -554,6 +554,7 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stimulus_resolution[0]), np.linspace(stim_ylim[0], stim_ylim[1], stimulus_resolution[1])] + self.stim_radius_px = stim_radius self.channels = channels self.channel_limits = [chan_xlim, chan_ylim] self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) @@ -793,8 +794,7 @@ def define_basis_functions_trigrid(self, channel_size, grid_radius): return self.channels - - def _define_trial_activations(self, stimuli): + def _define_trial_activations(self, stim_centers): """Defines a numpy matrix of predicted channel responses for each trial/observation. @@ -808,30 +808,13 @@ def _define_trial_activations(self, stimuli): C: matrix of predicted channel responses. dimensions are number of observations by stimulus resolution """ - # self.stim_xdomain = np.linspace(stim_fov[0][0], stim_fov[0][1], - # stimulus_resolution[0]) - # self.stim_ydomain = np.linspace(stim_fov[1][0], stim_fov[1][1], - # stimulus_resolution[1]) - stim_axis = np.linspace(self.range_start, self.range_stop - 1, - self.stim_res) - if self.range_start > 0: - stimuli = stimuli + self.range_start - elif self.range_start < 0: - stimuli = stimuli - self.range_start - one_hot = np.eye(self.stim_res) - indices = [np.argmin(abs(stim_axis - x)) for x in stimuli] - stimulus_mask = one_hot[indices, :] - if self.channel_density != self.stim_res: - if self.channel_density % self.stim_res == 0: - stimulus_mask = np.repeat(stimulus_mask, - self.channel_density / self.stim_res) - else: - raise NotImplementedError("This code doesn't currently support" - " stimuli which are not square " - "functions in the feature domain, or" - " stimulus widths that are not even" - "divisors of the number of points in" - " the feature domain.") + nstim = stim_centers.shape[0] + stimulus_mask = np.zeros((len(self.xp), nstim)) + for i in range(nstim): + rad_vals = ((self.xp - stim_centers[i, 0])**2 + + (self.yp - stim_centers[i, 1])**2) + inds = np.where(rad_vals < self.stim_radius_px)[0] + stimulus_mask[inds, i] = 1 C = stimulus_mask @ self.channels_.transpose() # Check that C is full rank From ec783acc28f2c5cefe869d0635d98531aa721412 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 18:25:27 -0700 Subject: [PATCH 05/39] added channel_exp in init. fixed reference to FWHM to cossz function. functions to create 2d channels now return the centers of the channels as well. --- brainiak/reconstruct/iem.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 38c462c1c..7e3a4cbb5 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -538,7 +538,7 @@ class InvertedEncoding2D(BaseEstimator): """ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius, - chan_xlim, chan_ylim, channels=None): + chan_xlim, chan_ylim, channels=None, channel_exp=5): # n_channels, stim_xlim, stim_ylim, stimulus_resolution, # chan_xlim, chan_ylim, channel_exp=5, # channel_arrangement='square'): @@ -555,9 +555,10 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius, np.linspace(stim_ylim[0], stim_ylim[1], stimulus_resolution[1])] self.stim_radius_px = stim_radius + self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) self.channels = channels self.channel_limits = [chan_xlim, chan_ylim] - self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) + self.channel_exp = channel_exp # self.n_channels = n_channels # self.channel_exp = channel_exp # self.channel_arrangement = channel_arrangement @@ -745,7 +746,7 @@ def define_basis_functions_sqgrid(self, nx, ny, channel_size=None): # spacing between the channels works. (See Sprague et al. 2013 # Methods & Supplementary Figure 3). channel_size = 1.1*(chan_xcenters[1] - chan_xcenters[0]) - cos_width = self._2d_cosine_fwhm_to_radians(channel_size) + cos_width = self._2d_cosine_fwhm_to_cossz(channel_size) # define exponentiated function self.channels = np.asarray( self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), @@ -753,9 +754,9 @@ def define_basis_functions_sqgrid(self, nx, ny, channel_size=None): cos_width)) self.n_channels = self.channels.size - return self.channels + return self.channels, np.vstack([chan_xcenters, chan_ycenters]) - def define_basis_functions_trigrid(self, channel_size, grid_radius): + def define_basis_functions_trigrid(self, grid_radius, channel_size=None): """Define basis functions (aka channels) arranged in a triangular grid. Returns @@ -784,7 +785,7 @@ def define_basis_functions_trigrid(self, channel_size, grid_radius): # spacing between the channels works. (See Sprague et al. 2013 # Methods & Supplementary Figure 3). channel_size = 1.1*x_dist - cos_width = self._2d_cosine_fwhm_to_radians(channel_size) + cos_width = self._2d_cosine_fwhm_to_cossz(channel_size) result = np.asarray(self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), trigrid[:, 0], trigrid[:, 1], @@ -792,7 +793,7 @@ def define_basis_functions_trigrid(self, channel_size, grid_radius): self.channels = result self.n_channels = result.size - return self.channels + return self.channels, trigrid def _define_trial_activations(self, stim_centers): """Defines a numpy matrix of predicted channel responses for From 7545f2bd364d4bace4a18fe285fb90364ba24a4c Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 18:59:08 -0700 Subject: [PATCH 06/39] modified function to create stimulus mask + channel activation matrix --- brainiak/reconstruct/iem.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 7e3a4cbb5..594eb2621 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -779,6 +779,7 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): yy = np.ones((xx.size, 1)) * y trigrid = np.vstack( (trigrid, np.hstack((xx, yy)))) + # TODO: self.channels only has 2 dimensions (my tests show 3) if channel_size is None: # To get even coverage, setting the channel FWHM to ~1.1x the @@ -810,14 +811,16 @@ def _define_trial_activations(self, stim_centers): number of observations by stimulus resolution """ nstim = stim_centers.shape[0] - stimulus_mask = np.zeros((len(self.xp), nstim)) + stimulus_mask = np.zeros((self.xp.size, nstim)) for i in range(nstim): - rad_vals = ((self.xp - stim_centers[i, 0])**2 + - (self.yp - stim_centers[i, 1])**2) + rad_vals = ((self.xp.reshape(-1, 1) - stim_centers[i, 0])**2 + + (self.yp.reshape(-1, 1) - stim_centers[i, 1])**2) inds = np.where(rad_vals < self.stim_radius_px)[0] stimulus_mask[inds, i] = 1 - C = stimulus_mask @ self.channels_.transpose() + # TODO: make sure C is the correct dimensionality. Does it need to be transposed? +# C = stimulus_mask @ self.channels.squeeze().transpose() + C = self.channels.squeeze() @ stimulus_mask # Check that C is full rank if np.linalg.matrix_rank(C) < self.n_channels: warnings.warn("Stimulus matrix is {}, not full rank. May cause " From 3141f2d946b45d6376f45a71299b36f54f6d8dea Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Tue, 29 Sep 2020 18:59:57 -0700 Subject: [PATCH 07/39] adding initial parts of a 2D IEM notebook --- .../iem2d_example_synthetic_RF_data.ipynb | 555 ++++++++++++++++++ 1 file changed, 555 insertions(+) create mode 100644 examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb diff --git a/examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb b/examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb new file mode 100644 index 000000000..51235afec --- /dev/null +++ b/examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb @@ -0,0 +1,555 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "# from brainiak.reconstruct import iem as IEM\n", + "import matplotlib.pyplot as plt\n", + "import numpy.matlib as matlib\n", + "import scipy.signal" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we will assume that the stimuli are circular checkerboards presented in 2-dimensional visual space. We will build an encoding model that has a grid of 6x6 channels, or basis functions, which also span this 2D space." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "import iem" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import importlib\n", + "importlib.reload(iem)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-8.5, 8.5] [-5, 5] [-6, 6] [-3, 3]\n" + ] + } + ], + "source": [ + "# Set up parameters\n", + "n_channels = [9, 5] # channels in the x, y directions\n", + "cos_exponent = 5\n", + "stimx, stimy = [-17/2, 17/2], [-5, 5]\n", + "stim_res = [171, 101]\n", + "stim_size = 1.449\n", + "chanx, chany = [-6, 6], [-3, 3]\n", + "print(stimx, stimy, chanx, chany)\n", + "\n", + "iem_obj = iem.InvertedEncoding2D(stim_xlim=stimx, stim_ylim=stimy,\n", + " stimulus_resolution=stim_res,\n", + " stim_radius=stim_size,\n", + " chan_xlim=chanx, chan_ylim=chany)\n", + "# stim_vals = np.linspace(0, feature_resolution - (feature_resolution/6), 6).astype(int)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The quality and interpretability of your stimulus reconstructions all depend on how you set up the channels, or basis functions, in the model. In order to ensure that you can accurately reconstruct stimuli at all portions in the area where you have presented stimuli, you will want to evenly space your basis functions in that region. You also will likely want to ensure some overlap between the basis functions.\n", + "\n", + "There are two pre-built functions to create a 2D grid of basis functions, to use a rectangular grid or a triangular grid. A triangular grid is more space-efficient, so let's use that.\n", + "\n", + "Note you will need to define these basis functions before you can fit the model. Otherwise it will throw an error." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(35, 17271, 1) (35, 2)\n" + ] + } + ], + "source": [ + "basis_fcns, basis_centers = iem_obj.define_basis_functions_trigrid(grid_radius=3.5)\n", + "print(basis_fcns.shape, basis_centers.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(basis_centers[:, 0], basis_centers[:, 1], '.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize these, you will need to reshape the second dimension into the 2D pixel space where the stimuli are represented." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "basis_res = np.reshape(basis_fcns, (basis_fcns.shape[0], stim_res[1], stim_res[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: create subplots of all of them\n", + "plt.imshow(basis_res[30, :, :].squeeze())" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: show summed together basis functions\n", + "# TODO: show cross-section of summed basis functions to demonstrate they are flat/smooth" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: load 2D fMRI data..." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(35, 17271, 1)\n", + "(17271, 20)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/vyvo/projects/brainiak/examples/reconstruct/iem.py:828: RuntimeWarning: Stimulus matrix is 16, not full rank. May cause issues with stimulus prediction/reconstruction.\n", + " np.linalg.matrix_rank(C)), RuntimeWarning)\n" + ] + } + ], + "source": [ + "sx = np.random.randint(0, high=12, size=(20, 1)) - 6\n", + "sy = np.random.randint(0, high=6, size=(20, 1)) - 3\n", + "\n", + "C = iem_obj._define_trial_activations(np.hstack((sx, sy)))" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(C)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll generate synthetic data. Ideally, each voxel that we measure from is roughly tuned to some part of the feature space (see Sprague, Boynton, Serences, 2019). So we will generate data that has a receptive field (RF). We can define the RF along the same feature axis as the channels that we generated above.\n", + "\n", + "The following two functions will generate the voxel RFs, and then generate several trials of that dataset. There are options to add uniform noise to either the RF or the trials." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate synthetic data s.t. each voxel has a Gaussian tuning function\n", + "\n", + "def generate_voxel_RFs(n_voxels, feature_resolution, random_tuning=True, RF_noise=0.):\n", + " if random_tuning:\n", + " # Voxel selectivity is random\n", + " voxel_tuning = np.floor((np.random.rand(n_voxels) * range_stop) + range_start).astype(int)\n", + " else:\n", + " # Voxel selectivity is evenly spaced along the feature axis\n", + " voxel_tuning = np.linspace(range_start, range_stop, n_voxels+1)\n", + " voxel_tuning = voxel_tuning[0:-1]\n", + " voxel_tuning = np.floor(voxel_tuning).astype(int)\n", + " gaussian = scipy.signal.gaussian(feature_resolution, 15)\n", + " voxel_RFs = np.zeros((n_voxels, feature_resolution))\n", + " for i in range(0, n_voxels):\n", + " voxel_RFs[i, :] = np.roll(gaussian, voxel_tuning[i] - ((feature_resolution//2)-1))\n", + " voxel_RFs += np.random.rand(n_voxels, feature_resolution)*RF_noise # add noise to voxel RFs\n", + " voxel_RFs = voxel_RFs / np.max(voxel_RFs, axis=1)[:, None]\n", + " \n", + " return voxel_RFs, voxel_tuning\n", + "\n", + "\n", + "def generate_voxel_data(voxel_RFs, n_voxels, trial_list, feature_resolution, \n", + " trial_noise=0.25):\n", + " one_hot = np.eye(feature_resolution)\n", + " # Generate trial-wise responses based on voxel RFs\n", + " if range_start > 0:\n", + " trial_list = trial_list + range_start\n", + " elif range_start < 0:\n", + " trial_list = trial_list - range_start\n", + " stim_X = one_hot[:, trial_list] #@ basis_set.transpose()\n", + " trial_data = voxel_RFs @ stim_X\n", + " trial_data += np.random.rand(n_voxels, trial_list.size)*(trial_noise*np.max(trial_data))\n", + " \n", + " return trial_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's generate some training data and look at it. This code will create a plot that depicts the response of an example voxel for different trials." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(100)\n", + "n_voxels = 50\n", + "n_train_trials = 120\n", + "training_stim = np.repeat(stim_vals, n_train_trials/6)\n", + "voxel_RFs, voxel_tuning = generate_voxel_RFs(n_voxels, feature_resolution, random_tuning=False, RF_noise=0.1)\n", + "train_data = generate_voxel_data(voxel_RFs, n_voxels, training_stim, feature_resolution, trial_noise=0.25)\n", + "print(np.linalg.cond(train_data))\n", + "# print(\"Voxels are tuned to: \", voxel_tuning)\n", + "\n", + "# Generate plots to look at the RF of an example voxel.\n", + "voxi = 20\n", + "f = plt.figure()\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(train_data[voxi, :])\n", + "plt.xlabel(\"trial\")\n", + "plt.ylabel(\"activation\")\n", + "plt.title(\"Activation over trials\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(voxel_RFs[voxi, :])\n", + "plt.xlabel(\"degrees (motion direction)\")\n", + "plt.axvline(voxel_tuning[voxi])\n", + "plt.title(\"Receptive field at {} deg\".format(voxel_tuning[voxi]))\n", + "plt.suptitle(\"Example voxel\")\n", + "\n", + "plt.figure()\n", + "plt.imshow(train_data)\n", + "plt.ylabel('voxel')\n", + "plt.xlabel('trial')\n", + "plt.suptitle('Simulated data from each voxel')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using this synthetic training data, we can fit the IEM." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Fit an IEM\n", + "iem_obj.fit(train_data.transpose(), training_stim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calling the IEM fit method defines the channels, or the basis set, which span the feature domain. We can examine the channels and plot them to check that they look appropriate.\n", + "\n", + "Remember that the plot below is in circular space. Hence, the channels wrap around the x-axis. For example, the channel depicted in blue is centered at 0 degrees (far left of plot), which is the same as 360 degrees (far right of plot).\n", + "\n", + "We can check whether the channels properly tile the feature space by summing across all of them. This is shown on the right plot. It should be a straight horizontal line." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Let's visualize the basis functions.\n", + "channels = iem_obj.channels_\n", + "feature_axis = iem_obj.channel_domain\n", + "print(channels.shape)\n", + "\n", + "plt.figure()\n", + "plt.subplot(1, 2, 1)\n", + "for i in range(0, channels.shape[0]):\n", + " plt.plot(feature_axis, channels[i,:])\n", + "plt.title('Channels (i.e. basis functions)')\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(np.sum(channels, 0))\n", + "plt.ylim(0, 2.5)\n", + "plt.title('Sum across channels')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can generate test data and see how well we can predict the test stimuli." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate test data\n", + "n_test_trials = 12\n", + "test_stim = np.repeat(stim_vals, n_test_trials/len(stim_vals))\n", + "np.random.seed(330)\n", + "test_data = generate_voxel_data(voxel_RFs, n_voxels, test_stim, feature_resolution, trial_noise=0.25)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Predict test stim & get R^2 score\n", + "pred_feature = iem_obj.predict(test_data.transpose())\n", + "R2 = iem_obj.score(test_data.transpose(), test_stim)\n", + "\n", + "print(\"Predicted features are: {} degrees.\".format(pred_feature))\n", + "print(\"Actual features are: {} degrees.\".format(test_stim))\n", + "print(\"Test R^2 is {}\".format(R2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to predicting the exact feature, we can examine the model-based reconstructions in the feature domain. That is, instead of getting single predicted values for each feature, we can look at a reconstructed function which peaks at the predicted feature.\n", + "\n", + "Below we will plot all of the reconstructions. There will be some variability because of the noise added during the synthetic data generation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Now get the model-based reconstructions, which are continuous\n", + "# functions that should peak at each test stimulus feature\n", + "recons = iem_obj._predict_feature_responses(test_data.transpose())\n", + "\n", + "f = plt.figure()\n", + "for i in range(0, n_test_trials-1):\n", + " plt.plot(feature_axis, recons[:, i])\n", + "for i in stim_vals:\n", + " plt.axvline(x=i, color='k', linestyle='--')\n", + "\n", + "plt.title(\"Reconstructions of {} degrees\".format(np.unique(test_stim)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For a sanity check, let's check how R^2 changes as the number of voxels increases. We can write a quick wrapper function to train and test on a given set of motion directions, as below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "iem_obj.verbose = False\n", + "def train_and_test(nvox, ntrn, ntst, rfn, tn):\n", + " vRFs, vox_tuning = generate_voxel_RFs(nvox, feature_resolution, random_tuning=True, RF_noise=rfn)\n", + " trn = np.repeat(stim_vals, ntrn/6).astype(int)\n", + " trnd = generate_voxel_data(vRFs, nvox, trn, feature_resolution, trial_noise=tn)\n", + " tst = np.repeat(stim_vals, ntst/6).astype(int)\n", + " tstd = generate_voxel_data(vRFs, nvox, tst, feature_resolution, trial_noise=tn)\n", + " \n", + " iem_obj.fit(trnd.transpose(), trn)\n", + " recons = iem_obj._predict_feature_responses(tstd.transpose())\n", + " pred_ori = iem_obj.predict(tstd.transpose())\n", + " R2 = iem_obj.score(tstd.transpose(), tst)\n", + "\n", + " return recons, pred_ori, R2, tst" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll iterate through the list and look at the resulting R^2 values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(300)\n", + "vox_list = (5, 10, 15, 25, 50)\n", + "R2_list = np.zeros(len(vox_list))\n", + "for idx, nvox in enumerate(vox_list):\n", + " recs, preds, R2_list[idx], test_features = train_and_test(nvox, 120, 30, 0.1, 0.25)\n", + "\n", + "print(\"The R2 values for increasing numbers of voxels: \")\n", + "print(R2_list)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 9657db2db0427c5d3e8093bff23d72d7c452298f Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 09:14:59 -0700 Subject: [PATCH 08/39] fixed dimensionality issues with basis functions and trial activations --- brainiak/reconstruct/iem.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 594eb2621..f1f87963e 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -722,7 +722,7 @@ def _2d_cosine_fwhm_to_cossz(self, fwhm): (np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5)) return cossz - def define_basis_functions_sqgrid(self, nx, ny, channel_size=None): + def define_basis_functions_sqgrid(self, nchannels, channel_size=None): """Define basis functions (aka channels) arrange in a square grid. Sets the self.channels parameter. @@ -738,9 +738,12 @@ def define_basis_functions_sqgrid(self, nx, ny, channel_size=None): channel_centers: numpy array of the centers of each channel """ chan_xcenters = np.linspace(self.channel_limits[0][0], - self.channel_limits[0][1], nx) + self.channel_limits[0][1], nchannels[0]) chan_ycenters = np.linspace(self.channel_limits[1][0], - self.channel_limits[1][1], ny) + self.channel_limits[1][1], nchannels[1]) + cx, cy = np.meshgrid(chan_xcenters, chan_ycenters) + cx = cx.reshape(-1, 1) + cy = cy.reshape(-1, 1) if channel_size is None: # To get even coverage, setting the channel FWHM to ~1.1x the # spacing between the channels works. (See Sprague et al. 2013 @@ -750,11 +753,11 @@ def define_basis_functions_sqgrid(self, nx, ny, channel_size=None): # define exponentiated function self.channels = np.asarray( self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), - chan_xcenters, chan_ycenters, - cos_width)) - self.n_channels = self.channels.size + cx, cy, + cos_width)).squeeze() + self.n_channels = self.channels.shape[0] - return self.channels, np.vstack([chan_xcenters, chan_ycenters]) + return self.channels, np.hstack([cx, cy]) def define_basis_functions_trigrid(self, grid_radius, channel_size=None): """Define basis functions (aka channels) arranged in a triangular grid. @@ -779,7 +782,6 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): yy = np.ones((xx.size, 1)) * y trigrid = np.vstack( (trigrid, np.hstack((xx, yy)))) - # TODO: self.channels only has 2 dimensions (my tests show 3) if channel_size is None: # To get even coverage, setting the channel FWHM to ~1.1x the @@ -790,9 +792,9 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): result = np.asarray(self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), trigrid[:, 0], trigrid[:, 1], - cos_width)) + cos_width)).squeeze() self.channels = result - self.n_channels = result.size + self.n_channels = result.shape[0] return self.channels, trigrid @@ -818,9 +820,8 @@ def _define_trial_activations(self, stim_centers): inds = np.where(rad_vals < self.stim_radius_px)[0] stimulus_mask[inds, i] = 1 - # TODO: make sure C is the correct dimensionality. Does it need to be transposed? -# C = stimulus_mask @ self.channels.squeeze().transpose() C = self.channels.squeeze() @ stimulus_mask + C = C.transpose() # Check that C is full rank if np.linalg.matrix_rank(C) < self.n_channels: warnings.warn("Stimulus matrix is {}, not full rank. May cause " From 35d128c99fc3a0cbcc1571ab06dd857e4cf74df5 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 12:39:41 -0700 Subject: [PATCH 09/39] forced _make_2d_cosine() to return a numpy array. Updated score() function. Edited and updated docstrings. --- brainiak/reconstruct/iem.py | 147 +++++++++++++++++++++--------------- 1 file changed, 85 insertions(+), 62 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index f1f87963e..1c07a1900 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -537,11 +537,9 @@ class InvertedEncoding2D(BaseEstimator): data """ - def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius, - chan_xlim, chan_ylim, channels=None, channel_exp=5): - # n_channels, stim_xlim, stim_ylim, stimulus_resolution, - # chan_xlim, chan_ylim, channel_exp=5, - # channel_arrangement='square'): + def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, + chan_xlim=[None, None], chan_ylim=[None, None], channels=None, + channel_exp=5): # Automatically expand n_channels or stimulus_resolution if only one # value is given. This will create a square basis set or square field # of view (FOV) for the reconstruction. @@ -649,7 +647,7 @@ def score(self, X, y): ---------- X: numpy matrix of voxel activation from new data [observations,voxels] - y: numpy array of responses. [observations] + y: numpy array of stimulus features. [observations, 2] Returns ------- @@ -657,15 +655,8 @@ def score(self, X, y): feature and predicted features. """ pred_features = self.predict(X) - if self.stimulus_mode == 'halfcircular': - # multiply features by 2. otherwise doesn't wrap properly - pred_features = pred_features * 2 - y = y * 2 - # TODO: replace this with a version for 2D space - ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features)) ** 2).sum() - sstot = (circ_dist(np.deg2rad(y), - np.ones(y.size) * scipy.stats.circmean( - np.deg2rad(y))) ** 2).sum() + ssres = (pred_features - y) ** 2 + sstot = (y - np.mean(y)) ** 2 score_value = (1 - ssres / sstot) return score_value @@ -700,24 +691,51 @@ def set_params(self, **parameters): return self def _make_2d_cosine(self, x, y, x_center, y_center, r): - # x, y is a meshgrid of x, y values at which to compute the 2d cos - # x_center, y_center is the center of the function - # r is the distance from center to 0 (T/2) - function will go from z = 0 to - # 0 across 2*r at widest point - z = [None] * len(x_center) + """Defines a 2D exponentiated cosine (isometric, e.g. constant width in x & y) + for use as a basis function. Function goes to zero at the given size constant r. + # TODO: put function here + + Parameters + ---------- + x: x-coordinates of the stimulus space, [npixels, 1] matrix + y: y-coordinates of the stimulus space, [npixels, 1] matrix + x_center: x-coordinate of basis function centers (sequence, nchannels elements) + y_center: y-coordinate of basis function centers (sequence, nchannels elements) + r: size constant of the 2D cosine function. This is the radius where the + function is non-zero. + + Returns + ------- + cos_functions: basis functions defined in the 2D stimulus space. returns a + [nchannels x npixels] matrix. + """ + cos_functions = np.zeros(len(x_center), len(x)) for i in range(len(x_center)): - myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2) #** 0.5 + myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2) qq = (myr <= r) * 1 zp = ((0.5 * (1 + np.cos(myr * np.pi / r))) ** self.channel_exp) - z[i] = zp * qq - return z + cos_functions[i, :] = zp * qq + return cos_functions - # def _calc_2d_cosine_fwhm(self, size_constant): - # fwhm = size_constant \ - # * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi - # return fwhm + #def _calc_2d_cosine_fwhm(self, size_constant): + # fwhm = size_constant \ + # * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi + # return fwhm def _2d_cosine_fwhm_to_cossz(self, fwhm): + """For a 2D cosine basis function with a given exponent, convert the full-width + half-maximum (FWHM) of that function to a size constant. + # TODO: put function here + # TODO: define size constant + + Parameters + ---------- + fwhm: a float value indicating the full-width half-maximum in stimulus space + + Returns + ------- + cossz: the size constant of the exponentiated cosine + """ cossz = (np.pi * fwhm) / \ (np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5)) return cossz @@ -728,8 +746,7 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): Parameters ---------- - nx: number of channels in the x (horizontal) direction - ny: number of channels in the y (vertical) direction + nchannels: number of channels in the x (horizontal) direction channel_size: the desired full-width half-maximum (FWHM) of the channel, in stimulus space. @@ -751,10 +768,8 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): channel_size = 1.1*(chan_xcenters[1] - chan_xcenters[0]) cos_width = self._2d_cosine_fwhm_to_cossz(channel_size) # define exponentiated function - self.channels = np.asarray( - self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), - cx, cy, - cos_width)).squeeze() + self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), + self.yp.reshape(-1, 1), cx, cy, cos_width) self.n_channels = self.channels.shape[0] return self.channels, np.hstack([cx, cy]) @@ -789,37 +804,46 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): # Methods & Supplementary Figure 3). channel_size = 1.1*x_dist cos_width = self._2d_cosine_fwhm_to_cossz(channel_size) - result = np.asarray(self._make_2d_cosine(self.xp.reshape(-1, 1), - self.yp.reshape(-1, 1), - trigrid[:, 0], trigrid[:, 1], - cos_width)).squeeze() - self.channels = result - self.n_channels = result.shape[0] + self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), + self.yp.reshape(-1, 1), trigrid[:, 0], + trigrid[:, 1], cos_width) + self.n_channels = self.channels.shape[0] return self.channels, trigrid - def _define_trial_activations(self, stim_centers): - """Defines a numpy matrix of predicted channel responses for - each trial/observation. + def _define_trial_activations(self, stim_centers, stim_radius=None): + """Defines a numpy matrix of predicted channel responses for each + trial/observation. Assumes that the presented stimulus is circular in the 2D + stimulus space. This can include a point -- simply set stim_radius to 0.5. Parameters - - stimuli: numpy array of the feature values for each - observation (e.g., [0, 5, 15, 30, ...] degrees) + ------- + stim_centers: numpy array of the 2D stimulus features for each observation, + expected dimensions are [observations, 2]. + stim_radius: scalar value or array-like sequence specifying the radius of the + circular stimulus (if array-like, should have n_observations elements) Returns ------- - C: matrix of predicted channel responses. dimensions are - number of observations by stimulus resolution + C: numpy array of predicted channel responses [observations, pixels] """ nstim = stim_centers.shape[0] + if self.stim_radius_px is None: + if stim_radius is None: + raise ValueError("No defined stimulus radius. Please set this value.") + else: + self.stim_radius_px = stim_radius + if not isinstance(self.stim_radius_px, np.ndarray) or not isinstance( + self.stim_radius_px, list): + self.stim_radius_px = np.ones(nstim) * self.stim_radius_px + # Create a mask for every stimulus observation in the stimulus domain stimulus_mask = np.zeros((self.xp.size, nstim)) for i in range(nstim): rad_vals = ((self.xp.reshape(-1, 1) - stim_centers[i, 0])**2 + (self.yp.reshape(-1, 1) - stim_centers[i, 1])**2) - inds = np.where(rad_vals < self.stim_radius_px)[0] + inds = np.where(rad_vals < self.stim_radius_px[i])[0] stimulus_mask[inds, i] = 1 - + # Go from the stimulus domain to the channel domain C = self.channels.squeeze() @ stimulus_mask C = C.transpose() # Check that C is full rank @@ -839,7 +863,7 @@ def _predict_channel_responses(self, X): Returns ------- - channel_response: numpy matrix of channel responses + channel_response: numpy matrix of channel responses [channels, observations] """ channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose()) return channel_response @@ -849,34 +873,33 @@ def _predict_feature_responses(self, X): functions defined in the feature domain. Parameters - --------- - X: numpy matrix of data. [observations, voxels] + --------- + X: numpy matrix of data. [observations, voxels] Returns ------- - pred_response: predict response from all channels. Used - to predict feature (e.g. direction). + pred_response: predict response from all channels. This is the stimulus + reconstruction in the channel domain. [pixels, observations] """ - pred_response = np.matmul(self.channels_.transpose(), + pred_response = np.matmul(self.channels.transpose(), self._predict_channel_responses(X)) return pred_response def _predict_features(self, X): """Predicts feature value (e.g. direction) from data in X. - Takes the maximum of the 'reconstructed' or predicted response - function. + Takes the maximum of the 'reconstructed' or predicted response function. Parameters - --------- - X: numpy matrix of data. [observations, voxels] + --------- + X: numpy matrix of data. [observations, voxels] Returns ------- - pred_features: predicted feature from response across all - channels. + pred_features: numpy matrix of predicted stimulus features. [observations, 2] """ pred_response = self._predict_feature_responses(X) feature_ind = np.argmax(pred_response, 0) - pred_features = self.channel_domain[feature_ind] + pred_features = np.hstack((self.xp.reshape(-1, 1)[feature_ind], + self.yp.reshape(-1, 1)[feature_ind])) return pred_features From 7d6fb86823b0a5c695101882894c4048dbafa334 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 13:52:14 -0700 Subject: [PATCH 10/39] added parameter checks; updated get & set functions --- brainiak/reconstruct/iem.py | 56 ++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 32 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 1c07a1900..4b6e0b481 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -540,11 +540,8 @@ class InvertedEncoding2D(BaseEstimator): def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, chan_xlim=[None, None], chan_ylim=[None, None], channels=None, channel_exp=5): - # Automatically expand n_channels or stimulus_resolution if only one - # value is given. This will create a square basis set or square field - # of view (FOV) for the reconstruction. - # if not isinstance(n_channels, list): # make basis set square - # n_channels = [n_channels, n_channels] + # Automatically expand stimulus_resolution if only one value is given. This + # will create a square field of view (FOV) for the reconstruction. if not isinstance(stimulus_resolution, list): # make FOV square stimulus_resolution = [stimulus_resolution, stimulus_resolution] self.stim_fov = [stim_xlim, stim_ylim] @@ -555,19 +552,24 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, self.stim_radius_px = stim_radius self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) self.channels = channels + if self.channels is None: + self.n_channels = None + else: + self.n_channels = self.channels.shape[0] self.channel_limits = [chan_xlim, chan_ylim] self.channel_exp = channel_exp - # self.n_channels = n_channels - # self.channel_exp = channel_exp - # self.channel_arrangement = channel_arrangement - # self._check_params() - # - # def _check_params(self): - # if any(self.n_channels < 2): - # raise ValueError("Insufficient number of channels.") - # if not np.isin(self.stimulus_mode, ['circular', 'halfcircular']): - # raise ValueError("Stimulus mode must be one of these: " - # "'circular', 'halfcircular'") + + def _check_params(self): + if self.n_channels and self.channels and \ + (self.n_channels != self.channels.shape[0]): + raise ValueError("Number of channels {} does not match the defined channels" + ": {}".format(self.n_channels, self.channels.shape[0])) + if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ + any(self.channels[:, 0] < self.channel_limits[0][0]) or \ + any(self.channels[:, 1] > self.channel_limits[1][1]) or \ + any(self.channels[:, 1] < self.channel_limits[1][0]): + raise ValueError("Channel limits and values defined in self.channels do not" + "match each other.") def fit(self, X, y): """Use data and feature variable labels to fit an IEM @@ -595,16 +597,10 @@ def fit(self, X, y): shape_data = np.shape(X) shape_labels = np.shape(y) if len(shape_data) != 2: - raise ValueError("Data matrix has too many or too few " - "dimensions.") + raise ValueError("Data matrix has too many or too few dimensions.") else: if shape_data[0] != shape_labels[0]: raise ValueError("Mismatched data samples and label samples") - - # # Define the channels (or basis set) - # self.channels_, channel_centers = self._define_channels() - # logger.info("Defined channels centered at {} degrees.".format( - # np.rad2deg(channel_centers))) # Create a matrix of channel activations for every observation. # (i.e., C1 in Brouwer & Heeger 2009.) C = self._define_trial_activations(y) @@ -669,12 +665,12 @@ def get_params(self): params: parameter of this object """ return {"n_channels": self.n_channels, "channel_exp": self.channel_exp, - "stimulus_mode": self.stimulus_mode, - "range_start": self.range_start, "range_stop": self.range_stop, - "channel_domain": self.channel_domain, - "stim_res": self.stim_res} + "stim_fov": self.stim_fov, "stim_pixels": self.stim_pixels, + "stim_radius_px": self.stim_radius_px, "xp": self.xp, "yp": self.yp, + "channels": self.channels, "channel_limits": self.channel_limits} def set_params(self, **parameters): + # TODO: update with real params """Sets model parameters after initialization. Parameters @@ -683,10 +679,6 @@ def set_params(self, **parameters): """ for parameter, value in parameters.items(): setattr(self, parameter, value) - - setattr(self, "channel_domain", - np.linspace(self.range_start, self.range_stop - 1, - self.channel_density)) self._check_params() return self @@ -886,7 +878,7 @@ def _predict_feature_responses(self, X): return pred_response def _predict_features(self, X): - """Predicts feature value (e.g. direction) from data in X. + """Predicts feature value from data in X. Takes the maximum of the 'reconstructed' or predicted response function. Parameters From df212c02f3c119c7632c59dfb65f19aeab54189d Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 14:02:48 -0700 Subject: [PATCH 11/39] added documentation & renamed size constant variable in 2d_cosine functions --- brainiak/reconstruct/iem.py | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 4b6e0b481..375763268 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -682,10 +682,14 @@ def set_params(self, **parameters): self._check_params() return self - def _make_2d_cosine(self, x, y, x_center, y_center, r): + def _make_2d_cosine(self, x, y, x_center, y_center, s): """Defines a 2D exponentiated cosine (isometric, e.g. constant width in x & y) - for use as a basis function. Function goes to zero at the given size constant r. - # TODO: put function here + for use as a basis function. Function goes to zero at the given size constant s. + That is, the function is given by + if r < s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp + else: 0 + where r is the Euclidean distance from the center of the function. This will + yield a Gaussian-like function, centered at (x_center, y_center). Parameters ---------- @@ -704,8 +708,8 @@ def _make_2d_cosine(self, x, y, x_center, y_center, r): cos_functions = np.zeros(len(x_center), len(x)) for i in range(len(x_center)): myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2) - qq = (myr <= r) * 1 - zp = ((0.5 * (1 + np.cos(myr * np.pi / r))) ** self.channel_exp) + qq = (myr <= s) * 1 + zp = ((0.5 * (1 + np.cos(myr * np.pi / s))) ** self.channel_exp) cos_functions[i, :] = zp * qq return cos_functions @@ -715,10 +719,12 @@ def _make_2d_cosine(self, x, y, x_center, y_center, r): # return fwhm def _2d_cosine_fwhm_to_cossz(self, fwhm): - """For a 2D cosine basis function with a given exponent, convert the full-width - half-maximum (FWHM) of that function to a size constant. - # TODO: put function here - # TODO: define size constant + """For an exponentiated 2D cosine basis function, converts the full-width + half-maximum (FWHM) of that function to the function's size constant. + The size constant is the variable s in the function below: + if r < s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp + else: 0 + where r is the Euclidean distance from the center of the function. Parameters ---------- From 6f9783b5f0dc08c495e19340a4d94ff481adfa21 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 16:12:30 -0700 Subject: [PATCH 12/39] fixed fwhm to cosine sz functions (off by a factor of 2). --- brainiak/reconstruct/iem.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 375763268..e3b8b9796 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -686,7 +686,7 @@ def _make_2d_cosine(self, x, y, x_center, y_center, s): """Defines a 2D exponentiated cosine (isometric, e.g. constant width in x & y) for use as a basis function. Function goes to zero at the given size constant s. That is, the function is given by - if r < s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp + if r <= s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp else: 0 where r is the Euclidean distance from the center of the function. This will yield a Gaussian-like function, centered at (x_center, y_center). @@ -705,24 +705,24 @@ def _make_2d_cosine(self, x, y, x_center, y_center, s): cos_functions: basis functions defined in the 2D stimulus space. returns a [nchannels x npixels] matrix. """ - cos_functions = np.zeros(len(x_center), len(x)) + cos_functions = np.zeros((len(x_center), len(x))) for i in range(len(x_center)): - myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2) + myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2).squeeze() qq = (myr <= s) * 1 zp = ((0.5 * (1 + np.cos(myr * np.pi / s))) ** self.channel_exp) cos_functions[i, :] = zp * qq return cos_functions - #def _calc_2d_cosine_fwhm(self, size_constant): - # fwhm = size_constant \ - # * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi - # return fwhm + def _2d_cosine_sz_to_fwhm(self, size_constant): + fwhm = 2 * size_constant \ + * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi + return fwhm - def _2d_cosine_fwhm_to_cossz(self, fwhm): + def _2d_cosine_fwhm_to_sz(self, fwhm): """For an exponentiated 2D cosine basis function, converts the full-width half-maximum (FWHM) of that function to the function's size constant. The size constant is the variable s in the function below: - if r < s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp + if r <= s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp else: 0 where r is the Euclidean distance from the center of the function. @@ -732,11 +732,11 @@ def _2d_cosine_fwhm_to_cossz(self, fwhm): Returns ------- - cossz: the size constant of the exponentiated cosine + sz: the size constant of the exponentiated cosine """ - cossz = (np.pi * fwhm) / \ + sz = (0.5 * np.pi * fwhm) / \ (np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5)) - return cossz + return sz def define_basis_functions_sqgrid(self, nchannels, channel_size=None): """Define basis functions (aka channels) arrange in a square grid. @@ -764,7 +764,7 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): # spacing between the channels works. (See Sprague et al. 2013 # Methods & Supplementary Figure 3). channel_size = 1.1*(chan_xcenters[1] - chan_xcenters[0]) - cos_width = self._2d_cosine_fwhm_to_cossz(channel_size) + cos_width = self._2d_cosine_fwhm_to_sz(channel_size) # define exponentiated function self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), cx, cy, cos_width) @@ -801,7 +801,7 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): # spacing between the channels works. (See Sprague et al. 2013 # Methods & Supplementary Figure 3). channel_size = 1.1*x_dist - cos_width = self._2d_cosine_fwhm_to_cossz(channel_size) + cos_width = self._2d_cosine_fwhm_to_sz(channel_size) self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), trigrid[:, 0], trigrid[:, 1], cos_width) From 5269b297c44b23c9bcc3a74e482be1cb78b31dac Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 17:25:33 -0700 Subject: [PATCH 13/39] minor changes to user docs + comments --- brainiak/reconstruct/iem.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index e3b8b9796..0ac27616c 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -670,7 +670,6 @@ def get_params(self): "channels": self.channels, "channel_limits": self.channel_limits} def set_params(self, **parameters): - # TODO: update with real params """Sets model parameters after initialization. Parameters @@ -760,10 +759,11 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): cx = cx.reshape(-1, 1) cy = cy.reshape(-1, 1) if channel_size is None: - # To get even coverage, setting the channel FWHM to ~1.1x the - # spacing between the channels works. (See Sprague et al. 2013 - # Methods & Supplementary Figure 3). - channel_size = 1.1*(chan_xcenters[1] - chan_xcenters[0]) + # To get even coverage, setting the channel FWHM to ~1.1x-1.2x the + # spacing between the channels might work. (See Sprague et al. 2013 + # Methods & Supplementary Figure 3 -- this is for cosine exponent 7, + # your mileage may vary for other exponents!). + channel_size = 1.2*(chan_xcenters[1] - chan_xcenters[0]) cos_width = self._2d_cosine_fwhm_to_sz(channel_size) # define exponentiated function self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), @@ -797,9 +797,10 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): (trigrid, np.hstack((xx, yy)))) if channel_size is None: - # To get even coverage, setting the channel FWHM to ~1.1x the - # spacing between the channels works. (See Sprague et al. 2013 - # Methods & Supplementary Figure 3). + # To get even coverage, setting the channel FWHM to ~1.1x-1.2x the + # spacing between the channels might work. (See Sprague et al. 2013 + # Methods & Supplementary Figure 3 -- this is for cosine exponent 7, + # your mileage may vary for other exponents!). channel_size = 1.1*x_dist cos_width = self._2d_cosine_fwhm_to_sz(channel_size) self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), @@ -866,7 +867,7 @@ def _predict_channel_responses(self, X): channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose()) return channel_response - def _predict_feature_responses(self, X): + def predict_feature_responses(self, X): """Takes channel weights and transforms them into continuous functions defined in the feature domain. @@ -895,7 +896,7 @@ def _predict_features(self, X): ------- pred_features: numpy matrix of predicted stimulus features. [observations, 2] """ - pred_response = self._predict_feature_responses(X) + pred_response = self.predict_feature_responses(X) feature_ind = np.argmax(pred_response, 0) pred_features = np.hstack((self.xp.reshape(-1, 1)[feature_ind], self.yp.reshape(-1, 1)[feature_ind])) From 05b2d0271a2aabcb313c68f131e0e2b172c2037c Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 17:29:00 -0700 Subject: [PATCH 14/39] initial version of notebook with IEM tutorial data (2d spatial recons) --- examples/reconstruct/iem2d_example.ipynb | 422 +++++++++++++ .../iem2d_example_synthetic_RF_data.ipynb | 555 ------------------ 2 files changed, 422 insertions(+), 555 deletions(-) create mode 100644 examples/reconstruct/iem2d_example.ipynb delete mode 100644 examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb diff --git a/examples/reconstruct/iem2d_example.ipynb b/examples/reconstruct/iem2d_example.ipynb new file mode 100644 index 000000000..a70581e6e --- /dev/null +++ b/examples/reconstruct/iem2d_example.ipynb @@ -0,0 +1,422 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "# from brainiak.reconstruct import iem as IEM\n", + "import matplotlib.pyplot as plt\n", + "# import numpy.matlib as matlib\n", + "# import scipy.signal\n", + "import scipy.io" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we will assume that the stimuli are circular checkerboards presented in 2-dimensional visual space. We will build an encoding model that has a grid of 6x6 channels, or basis functions, which also span this 2D space.\n", + "\n", + "The dataset, as described by the IEM tutorial written by Thomas Sprague & John Serences for MATLAB (https://github.com/tommysprague/IEM-tutorial):\n", + "\n", + "\"Participants viewed peripheral flickering checkerboard stimuli presented at a range of contrasts (0-70%, logarithmically spaced) while performing either a demanding target detection task (contrast change) at the stimulus position (\"attend stimulus\" condition) or at the fixation point (\"attend fixation\" condition). The stimuli appeared randomly on the left or right side of the screen. Targets appeared rarely, and trials in which targets do appear are not included in analyses. Thus, sensory conditions are perfectly equated across the attend stimulus and the attend fixation conditions.\n", + "\n", + "In addition to this main attention task, paricipants also performed a \"spatial mapping\" task in which they viewed small checkerboard discs presented at different positions on the screen while they performed a demanding fixation task (contrast change detection).\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the fMRI data\n", + "data = scipy.io.loadmat('AL61_Bilat-V1_attnContrast.mat')\n", + "trn_conds = data['trn_conds'] # position in space for 128 trials\n", + "# flip to cartesian coordinates to make life easier\n", + "trn_conds[:,1] = trn_conds[:,1]*-1\n", + "trn = data['trn'] # matrix of (trials, voxels)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2] [1 2 3 4 5 6]\n" + ] + } + ], + "source": [ + "# Note there are several different conditions in the test data.\n", + "tst_conds = data['tst_conds']\n", + "tst = data['tst']\n", + "attn_conds = np.unique(tst_conds[:, 2])\n", + "stim_contrasts = np.unique(tst_conds[:, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import iem" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import importlib\n", + "importlib.reload(iem)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up parameters\n", + "n_channels = [9, 5] # channels in the x, y directions\n", + "cos_exponent = 5\n", + "stimx, stimy = [-17/2, 17/2], [-5, 5]\n", + "stim_res = [171, 101]\n", + "npixels = stim_res[0] * stim_res[1]\n", + "stim_size = 1.449\n", + "# chanx, chany = [-6, 6], [-3, 3]\n", + "chanx = np.array([-4, 4]) * stim_size\n", + "chany = np.array([-2, 2]) * stim_size" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "iem_obj = iem.InvertedEncoding2D(stim_xlim=stimx, stim_ylim=stimy,\n", + " stimulus_resolution=stim_res,\n", + " stim_radius=stim_size,\n", + " chan_xlim=chanx, chan_ylim=chany,\n", + " channel_exp=7)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.55819175 1.8112440203407754\n", + "4.55819175\n", + "1.81125\n" + ] + } + ], + "source": [ + "s = stim_size * 1.25 * 2.5166\n", + "fwhm = iem_obj._2d_cosine_sz_to_fwhm(s)\n", + "print(s, fwhm)\n", + "print(iem_obj._2d_cosine_fwhm_to_sz(fwhm))\n", + "\n", + "print(s / 2.5166)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The quality and interpretability of your stimulus reconstructions all depend on how you set up the channels, or basis functions, in the model. In order to ensure that you can accurately reconstruct stimuli at all portions in the area where you have presented stimuli, you will want to evenly space your basis functions in that region. You also will likely want to ensure some overlap between the basis functions.\n", + "\n", + "There are two pre-built functions to create a 2D grid of basis functions, to use a rectangular grid or a triangular grid. A triangular grid is more space-efficient, so let's use that.\n", + "\n", + "Note you will need to define these basis functions before you can fit the model. Otherwise it will throw an error." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "basis_fcns, basis_centers = iem_obj.define_basis_functions_sqgrid(n_channels)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(basis_centers[:, 0], basis_centers[:, 1], '.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize these, you will need to reshape the second dimension into the 2D pixel space where the stimuli are represented." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: prettify the plots\n", + "f, ax = plt.subplots(n_channels[1], n_channels[0])\n", + "i = 0\n", + "for ii in range(n_channels[1]):\n", + " for jj in range(n_channels[0]):\n", + " ax[ii, jj].imshow(basis_fcns[i, :].reshape(stim_res[1], \n", + " stim_res[0]))\n", + " ax[ii, jj].axes.get_xaxis().set_visible(False)\n", + " ax[ii, jj].axes.get_yaxis().set_visible(False)\n", + " i += 1\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: show summed together basis functions\n", + "# TODO: show cross-section of summed basis functions to demonstrate they are flat/smooth" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(128, 45)\n" + ] + } + ], + "source": [ + "# nobs = 100\n", + "# sx = np.linspace(-6, 6, 10) #np.random.randint(0, high=12, size=(nobs, 1)) - 6\n", + "# sy = np.linspace(-3, 3, 10) #np.random.randint(0, high=6, size=(nobs, 1)) - 3\n", + "# sxx, syy = np.meshgrid(sx, sy)\n", + "# ydata = np.hstack((sxx.reshape(-1, 1), syy.reshape(-1, 1)))\n", + "\n", + "C = iem_obj._define_trial_activations(trn_conds)\n", + "print(C.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(C)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(653, 45)\n" + ] + } + ], + "source": [ + "# nvox = 1000\n", + "# X = np.zeros((nobs, nvox))\n", + "# for i, l in enumerate(np.linspace(-1, 1, 10)):\n", + "# X[i*10:i*10+10, :] = np.random.normal(loc=l, scale=1.5, \n", + "# size=(10, nvox))\n", + "iem_obj = iem_obj.fit(trn, trn_conds)\n", + "\n", + "print(iem_obj.W_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(17271, 288)\n" + ] + } + ], + "source": [ + "stim_reconstructions = iem_obj.predict_feature_responses(tst)\n", + "print(stim_reconstructions.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "vmin, vmax = 0, 0\n", + "mean_recons = np.zeros((stim_contrasts.size, attn_conds.size, npixels))\n", + "\n", + "for aa, attn_cond in enumerate(attn_conds):\n", + " for ss, contrast in enumerate(stim_contrasts):\n", + " thisidx = np.argwhere((tst_conds[:, 0] == 1) &\n", + " (tst_conds[:, 1] == contrast) &\n", + " (tst_conds[:, 2] == attn_cond) &\n", + " (tst_conds[:, 3] == 0))\n", + " rs = np.mean(stim_reconstructions[:, thisidx], axis=1)\n", + " if rs.min() < vmin:\n", + " vmin = rs.min()\n", + " if rs.max() > vmax:\n", + " vmax = rs.max()\n", + " mean_recons[ss, aa, :] = rs.squeeze()" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(6, 2, figsize=(10,16))\n", + "for aa, attn_cond in enumerate(attn_conds):\n", + " for ss, contrast in enumerate(stim_contrasts):\n", + " ax[ss, aa].imshow(mean_recons[ss, aa, :].\\\n", + " reshape(stim_res[1], stim_res[0]),\n", + " origin='lower', interpolation='none',\n", + " cmap='inferno',\n", + " extent=[stimx[0], stimx[1], stimy[0], stimy[1]],\n", + " vmin=vmin, vmax=vmax)\n", + " if contrast == stim_contrasts[0]:\n", + " if attn_cond == 1:\n", + " ax[ss, aa].set_title('Attend fixation')\n", + " elif attn_cond == 2:\n", + " ax[ss, aa].set_title('Attend stimulus')\n", + " if attn_cond == 1:\n", + " ax[ss, aa].set_ylabel('Contrast value {}'.format(contrast))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# X2 = np.zeros((5, nvox))\n", + "# for i, l in enumerate(np.linspace(-1, 1, 5)):\n", + "# X2[i, :] = np.random.normal(loc=l, scale=1.5, \n", + "# size=(1, nvox))\n", + "# pred_vals = iem_obj.predict()\n", + "# print(pred_vals, pred_vals.shape)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb b/examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb deleted file mode 100644 index 51235afec..000000000 --- a/examples/reconstruct/iem2d_example_synthetic_RF_data.ipynb +++ /dev/null @@ -1,555 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "# from brainiak.reconstruct import iem as IEM\n", - "import matplotlib.pyplot as plt\n", - "import numpy.matlib as matlib\n", - "import scipy.signal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this example, we will assume that the stimuli are circular checkerboards presented in 2-dimensional visual space. We will build an encoding model that has a grid of 6x6 channels, or basis functions, which also span this 2D space." - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "import iem" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import importlib\n", - "importlib.reload(iem)" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-8.5, 8.5] [-5, 5] [-6, 6] [-3, 3]\n" - ] - } - ], - "source": [ - "# Set up parameters\n", - "n_channels = [9, 5] # channels in the x, y directions\n", - "cos_exponent = 5\n", - "stimx, stimy = [-17/2, 17/2], [-5, 5]\n", - "stim_res = [171, 101]\n", - "stim_size = 1.449\n", - "chanx, chany = [-6, 6], [-3, 3]\n", - "print(stimx, stimy, chanx, chany)\n", - "\n", - "iem_obj = iem.InvertedEncoding2D(stim_xlim=stimx, stim_ylim=stimy,\n", - " stimulus_resolution=stim_res,\n", - " stim_radius=stim_size,\n", - " chan_xlim=chanx, chan_ylim=chany)\n", - "# stim_vals = np.linspace(0, feature_resolution - (feature_resolution/6), 6).astype(int)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The quality and interpretability of your stimulus reconstructions all depend on how you set up the channels, or basis functions, in the model. In order to ensure that you can accurately reconstruct stimuli at all portions in the area where you have presented stimuli, you will want to evenly space your basis functions in that region. You also will likely want to ensure some overlap between the basis functions.\n", - "\n", - "There are two pre-built functions to create a 2D grid of basis functions, to use a rectangular grid or a triangular grid. A triangular grid is more space-efficient, so let's use that.\n", - "\n", - "Note you will need to define these basis functions before you can fit the model. Otherwise it will throw an error." - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(35, 17271, 1) (35, 2)\n" - ] - } - ], - "source": [ - "basis_fcns, basis_centers = iem_obj.define_basis_functions_trigrid(grid_radius=3.5)\n", - "print(basis_fcns.shape, basis_centers.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(basis_centers[:, 0], basis_centers[:, 1], '.')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To visualize these, you will need to reshape the second dimension into the 2D pixel space where the stimuli are represented." - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [], - "source": [ - "basis_res = np.reshape(basis_fcns, (basis_fcns.shape[0], stim_res[1], stim_res[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 73, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# TODO: create subplots of all of them\n", - "plt.imshow(basis_res[30, :, :].squeeze())" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO: show summed together basis functions\n", - "# TODO: show cross-section of summed basis functions to demonstrate they are flat/smooth" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO: load 2D fMRI data..." - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(35, 17271, 1)\n", - "(17271, 20)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/vyvo/projects/brainiak/examples/reconstruct/iem.py:828: RuntimeWarning: Stimulus matrix is 16, not full rank. May cause issues with stimulus prediction/reconstruction.\n", - " np.linalg.matrix_rank(C)), RuntimeWarning)\n" - ] - } - ], - "source": [ - "sx = np.random.randint(0, high=12, size=(20, 1)) - 6\n", - "sy = np.random.randint(0, high=6, size=(20, 1)) - 3\n", - "\n", - "C = iem_obj._define_trial_activations(np.hstack((sx, sy)))" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(C)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we'll generate synthetic data. Ideally, each voxel that we measure from is roughly tuned to some part of the feature space (see Sprague, Boynton, Serences, 2019). So we will generate data that has a receptive field (RF). We can define the RF along the same feature axis as the channels that we generated above.\n", - "\n", - "The following two functions will generate the voxel RFs, and then generate several trials of that dataset. There are options to add uniform noise to either the RF or the trials." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Generate synthetic data s.t. each voxel has a Gaussian tuning function\n", - "\n", - "def generate_voxel_RFs(n_voxels, feature_resolution, random_tuning=True, RF_noise=0.):\n", - " if random_tuning:\n", - " # Voxel selectivity is random\n", - " voxel_tuning = np.floor((np.random.rand(n_voxels) * range_stop) + range_start).astype(int)\n", - " else:\n", - " # Voxel selectivity is evenly spaced along the feature axis\n", - " voxel_tuning = np.linspace(range_start, range_stop, n_voxels+1)\n", - " voxel_tuning = voxel_tuning[0:-1]\n", - " voxel_tuning = np.floor(voxel_tuning).astype(int)\n", - " gaussian = scipy.signal.gaussian(feature_resolution, 15)\n", - " voxel_RFs = np.zeros((n_voxels, feature_resolution))\n", - " for i in range(0, n_voxels):\n", - " voxel_RFs[i, :] = np.roll(gaussian, voxel_tuning[i] - ((feature_resolution//2)-1))\n", - " voxel_RFs += np.random.rand(n_voxels, feature_resolution)*RF_noise # add noise to voxel RFs\n", - " voxel_RFs = voxel_RFs / np.max(voxel_RFs, axis=1)[:, None]\n", - " \n", - " return voxel_RFs, voxel_tuning\n", - "\n", - "\n", - "def generate_voxel_data(voxel_RFs, n_voxels, trial_list, feature_resolution, \n", - " trial_noise=0.25):\n", - " one_hot = np.eye(feature_resolution)\n", - " # Generate trial-wise responses based on voxel RFs\n", - " if range_start > 0:\n", - " trial_list = trial_list + range_start\n", - " elif range_start < 0:\n", - " trial_list = trial_list - range_start\n", - " stim_X = one_hot[:, trial_list] #@ basis_set.transpose()\n", - " trial_data = voxel_RFs @ stim_X\n", - " trial_data += np.random.rand(n_voxels, trial_list.size)*(trial_noise*np.max(trial_data))\n", - " \n", - " return trial_data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's generate some training data and look at it. This code will create a plot that depicts the response of an example voxel for different trials." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.random.seed(100)\n", - "n_voxels = 50\n", - "n_train_trials = 120\n", - "training_stim = np.repeat(stim_vals, n_train_trials/6)\n", - "voxel_RFs, voxel_tuning = generate_voxel_RFs(n_voxels, feature_resolution, random_tuning=False, RF_noise=0.1)\n", - "train_data = generate_voxel_data(voxel_RFs, n_voxels, training_stim, feature_resolution, trial_noise=0.25)\n", - "print(np.linalg.cond(train_data))\n", - "# print(\"Voxels are tuned to: \", voxel_tuning)\n", - "\n", - "# Generate plots to look at the RF of an example voxel.\n", - "voxi = 20\n", - "f = plt.figure()\n", - "plt.subplot(1, 2, 1)\n", - "plt.plot(train_data[voxi, :])\n", - "plt.xlabel(\"trial\")\n", - "plt.ylabel(\"activation\")\n", - "plt.title(\"Activation over trials\")\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(voxel_RFs[voxi, :])\n", - "plt.xlabel(\"degrees (motion direction)\")\n", - "plt.axvline(voxel_tuning[voxi])\n", - "plt.title(\"Receptive field at {} deg\".format(voxel_tuning[voxi]))\n", - "plt.suptitle(\"Example voxel\")\n", - "\n", - "plt.figure()\n", - "plt.imshow(train_data)\n", - "plt.ylabel('voxel')\n", - "plt.xlabel('trial')\n", - "plt.suptitle('Simulated data from each voxel')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using this synthetic training data, we can fit the IEM." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Fit an IEM\n", - "iem_obj.fit(train_data.transpose(), training_stim)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Calling the IEM fit method defines the channels, or the basis set, which span the feature domain. We can examine the channels and plot them to check that they look appropriate.\n", - "\n", - "Remember that the plot below is in circular space. Hence, the channels wrap around the x-axis. For example, the channel depicted in blue is centered at 0 degrees (far left of plot), which is the same as 360 degrees (far right of plot).\n", - "\n", - "We can check whether the channels properly tile the feature space by summing across all of them. This is shown on the right plot. It should be a straight horizontal line." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Let's visualize the basis functions.\n", - "channels = iem_obj.channels_\n", - "feature_axis = iem_obj.channel_domain\n", - "print(channels.shape)\n", - "\n", - "plt.figure()\n", - "plt.subplot(1, 2, 1)\n", - "for i in range(0, channels.shape[0]):\n", - " plt.plot(feature_axis, channels[i,:])\n", - "plt.title('Channels (i.e. basis functions)')\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(np.sum(channels, 0))\n", - "plt.ylim(0, 2.5)\n", - "plt.title('Sum across channels')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can generate test data and see how well we can predict the test stimuli." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Generate test data\n", - "n_test_trials = 12\n", - "test_stim = np.repeat(stim_vals, n_test_trials/len(stim_vals))\n", - "np.random.seed(330)\n", - "test_data = generate_voxel_data(voxel_RFs, n_voxels, test_stim, feature_resolution, trial_noise=0.25)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Predict test stim & get R^2 score\n", - "pred_feature = iem_obj.predict(test_data.transpose())\n", - "R2 = iem_obj.score(test_data.transpose(), test_stim)\n", - "\n", - "print(\"Predicted features are: {} degrees.\".format(pred_feature))\n", - "print(\"Actual features are: {} degrees.\".format(test_stim))\n", - "print(\"Test R^2 is {}\".format(R2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In addition to predicting the exact feature, we can examine the model-based reconstructions in the feature domain. That is, instead of getting single predicted values for each feature, we can look at a reconstructed function which peaks at the predicted feature.\n", - "\n", - "Below we will plot all of the reconstructions. There will be some variability because of the noise added during the synthetic data generation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Now get the model-based reconstructions, which are continuous\n", - "# functions that should peak at each test stimulus feature\n", - "recons = iem_obj._predict_feature_responses(test_data.transpose())\n", - "\n", - "f = plt.figure()\n", - "for i in range(0, n_test_trials-1):\n", - " plt.plot(feature_axis, recons[:, i])\n", - "for i in stim_vals:\n", - " plt.axvline(x=i, color='k', linestyle='--')\n", - "\n", - "plt.title(\"Reconstructions of {} degrees\".format(np.unique(test_stim)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For a sanity check, let's check how R^2 changes as the number of voxels increases. We can write a quick wrapper function to train and test on a given set of motion directions, as below." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "iem_obj.verbose = False\n", - "def train_and_test(nvox, ntrn, ntst, rfn, tn):\n", - " vRFs, vox_tuning = generate_voxel_RFs(nvox, feature_resolution, random_tuning=True, RF_noise=rfn)\n", - " trn = np.repeat(stim_vals, ntrn/6).astype(int)\n", - " trnd = generate_voxel_data(vRFs, nvox, trn, feature_resolution, trial_noise=tn)\n", - " tst = np.repeat(stim_vals, ntst/6).astype(int)\n", - " tstd = generate_voxel_data(vRFs, nvox, tst, feature_resolution, trial_noise=tn)\n", - " \n", - " iem_obj.fit(trnd.transpose(), trn)\n", - " recons = iem_obj._predict_feature_responses(tstd.transpose())\n", - " pred_ori = iem_obj.predict(tstd.transpose())\n", - " R2 = iem_obj.score(tstd.transpose(), tst)\n", - "\n", - " return recons, pred_ori, R2, tst" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We'll iterate through the list and look at the resulting R^2 values." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.random.seed(300)\n", - "vox_list = (5, 10, 15, 25, 50)\n", - "R2_list = np.zeros(len(vox_list))\n", - "for idx, nvox in enumerate(vox_list):\n", - " recs, preds, R2_list[idx], test_features = train_and_test(nvox, 120, 30, 0.1, 0.25)\n", - "\n", - "print(\"The R2 values for increasing numbers of voxels: \")\n", - "print(R2_list)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 56d49576252109aa4516fad88e00bc9a5aee12c5 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 30 Sep 2020 17:44:33 -0700 Subject: [PATCH 15/39] removed unnecessary bits in the notebook. added TODOs for the text --- examples/reconstruct/iem2d_example.ipynb | 253 +++++++++-------------- 1 file changed, 99 insertions(+), 154 deletions(-) diff --git a/examples/reconstruct/iem2d_example.ipynb b/examples/reconstruct/iem2d_example.ipynb index a70581e6e..476dd1ebd 100644 --- a/examples/reconstruct/iem2d_example.ipynb +++ b/examples/reconstruct/iem2d_example.ipynb @@ -7,10 +7,8 @@ "outputs": [], "source": [ "import numpy as np\n", - "# from brainiak.reconstruct import iem as IEM\n", + "from brainiak.reconstruct import iem as IEM\n", "import matplotlib.pyplot as plt\n", - "# import numpy.matlib as matlib\n", - "# import scipy.signal\n", "import scipy.io" ] }, @@ -41,6 +39,13 @@ "trn = data['trn'] # matrix of (trials, voxels)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TODO: explain the test data & conditions" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -62,36 +67,6 @@ "stim_contrasts = np.unique(tst_conds[:, 1])" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import iem" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import importlib\n", - "importlib.reload(iem)" - ] - }, { "cell_type": "code", "execution_count": 6, @@ -105,9 +80,7 @@ "stim_res = [171, 101]\n", "npixels = stim_res[0] * stim_res[1]\n", "stim_size = 1.449\n", - "# chanx, chany = [-6, 6], [-3, 3]\n", - "chanx = np.array([-4, 4]) * stim_size\n", - "chany = np.array([-2, 2]) * stim_size" + "chanx, chany = [-6, 6], [-3, 3]" ] }, { @@ -123,30 +96,6 @@ " channel_exp=7)" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4.55819175 1.8112440203407754\n", - "4.55819175\n", - "1.81125\n" - ] - } - ], - "source": [ - "s = stim_size * 1.25 * 2.5166\n", - "fwhm = iem_obj._2d_cosine_sz_to_fwhm(s)\n", - "print(s, fwhm)\n", - "print(iem_obj._2d_cosine_fwhm_to_sz(fwhm))\n", - "\n", - "print(s / 2.5166)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -167,15 +116,6 @@ "basis_fcns, basis_centers = iem_obj.define_basis_functions_sqgrid(n_channels)" ] }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(basis_centers[:, 0], basis_centers[:, 1], '.')" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -185,14 +125,26 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 71, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAADYCAYAAADVjzngAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAn6ElEQVR4nO3dWYwd133n8e85VffW3fr2vnCnbC229mVCRottLWM7DjDAJEAyyUOcABMMjCAZjAEBSYAAAwNBAgSBgXg8kyCZDJLAgccDw+OHYKAkllctlhxJlmiJWiiRTXaz97tvVbfqnHmopkhJ3ZQuRfKUnP/nSapukj/WOfWr6nNKV8paixBCiKtPuw4ghBD/WkkBCyGEI1LAQgjhiBSwEEI4IgUshBCOSAELIYQj/ijfnFeBLVBGaQ25HDbvYQEdGxgOsUkCV+ittgFdIhuqi+V6kwLleZDLYXyNAlSUpBmNcZfrQkqhfA+bz2E9hUosahjDMOZyvBq4W66LZrowntaQ87E5D6sVKjaoKN4e40vP16a+aa2dvdRcb8noeZDzMTkPAD1M0vOXJE5znQ+oUJ6HzftYX6OMRZ3L+B7n4RXJ9ZaIanuc/fPzMBpi44uP85XO9ZaMI/TN1cx1PuDF++ZiHTFSARco87OFn0cf2Evt6Dwbd4EpGcZf9Fl4ool69TSm03lfF+hunrKPXjTXUfVQ+i9KoUsl7PWHWbt3nMZNMXqgmX0Gpp5ax5xexobh1c91Ie3hTU0Q3nqYlbsD+oeG5Nd89vwwpvzsGZKNTWwcX5Fcu2a6gMrl8RbmaB7Zx9oRTTwRUzmRY8/jXfyXTpE0W5c8xt+yX1+81FwX0oUC6sOHWL97itrtaZlN/Vgz92QN+/oiZjBwkutNSuGNV4lvPMzKvWU61w7xGz7zTxvGn14mWV3HDqOrn+vCiL6PNztD984DrPysTzQfU1zMsefJkOCFUyS1Bpidb2ZXMtdbMgYB+uA+akfn0r4pGCZe9Jl/vIl69RSm13vLXLxauc4HVOhKBXv9QVbvGad5U4zuneubNcyZs/xw8P92/eUjL0GofJ54tsrWLYpfffBxvnD/N2gf6dM7UEYVCqDcr2qoUon+/jLNIwO+8MA3+OyD32frFkU8O4bK513HQ2mFGqvQ/FCeqY+t8mcP/D233P8a9etz2Ikx8Dy3+TyNma5S+6jHJx98jj994GtwT4P24SKqXHY/xkqhCgHhQoWtOxM+/8AjfP6BR9i6MyFcqKAKAagdHziuYkaNKpdpHy7CPQ3+9IGv8ckHn6P2UQ8zXUV57q8TPA87MUb9+hy33P8af/bA3zP1sVWaH8qjxioo7fgccq5vxti6RfHZB7/PFx74Bs0jA/r7y6hSyXW8dJwLBXoHyrSP9PnC/d/gVx98fLtvqu/aNyM9AZ//QwENJR1R1hHKs1jXE/6c7XKwHihtKeuIkhdiPXv+olTqijylj8pqyHkJZR2S1wk2A9ckAFpjlcJqKOqIMd3H1wabkSEGQOk0j4aS3v6JRpMec32DuIBV4GvDmO5T1BFWg1Uq/bE6I6yGvE7nYc5L6Gcl2gXXq/UsJS9M+0Zb7LlnFKXBjr7kdLlZpVDedt/oKH20fQ/Xy8gFbKMIf7PD5Esl/qryCSgmjP0koLzUxg4GYC/vGuvIrMEOBpSW+5SfHePh4S/BwGPmRYW/0cZEkfPytcZiOz3GTw05++Re/tPqZ9FnC+x5PUa1unAJa5iXNd8wxqu3mXx1jG/+4Aj/d+p2ii8XmDndx/b6GRhjiw1DgvUuk89P8ofevwNg8nmPYL2VLjG5vsFag+31GTsd0n5qis81fw1VyzP/qsGrt0mG72+J6bJIElSry8Trk/zosY/w1N7D5E4W2HtqiO30sMb1ObRp32y0mXyxyP8oPwSFhLFjAaXlbPVNealH6ZkxHg5/Cfoesy+Bv9lJ++YiLqmAWd1g5mmPytkqxtcU1lvoxTVMv5+BiW+x/T761Cp7jWHwcgmVGIpnGrC6gc3CxDcJptWieHyVg90Zwsk8uU5IsLiFqTcuaRPpcrLxELOxxcQzPsWNSZKCR7DVwV9cJ+l03Y8xYAYh3pk15p9QjJ+sAFBYaaDOrJEMLt8a/yWzFtPpkj+xwv7hHOHzAd5gSHC6jtnYwsZD1wmxSYKpNxh7Pke+Mc2wkiOo98md3iRptXZd/72qGYcxrG4w+1TaN9bTFNaa6NPr2esbaxkcL6JjQ2GpkfbN5S5grCXpdNGnliisBKAVNhpi+v33vXF0udg4xtTrqF6P0qkATPrEZAZhJiYVpDeyZHUdv9nCz+cgjkn6g3TAMjCpTK+HPnOWYLMOnsaGEckgfE8bR1eFSUiaLfSJiOJSAIAdhCT9QXbGeBiRbNbQnS6lIA+Jwfb7mCw8oUM6zv0+9uwq+XqDvO9DNEznYQZuEEA6ztt9UzzXN4MQE4bZ65vBgNLJ3Fv75l3G+dLWgE2S7j72+xekyMCEuoCNt19H6vW2D2QrH9amF+iFEz1LGa1N3yS48I2RLOWDdB52u9kdY9IStvEQOucOZCzj9nJOcuGTWtYyflD6ptO54MB7y3dpBTziH+JM1vNB9jNmPR9kP2PW84FkvBwuIV9W9juFEOJfHSlgIYRwRApYCCEckQIWQghHpICFEMIRKWAhhHBEClgIIRyRAhZCCEekgIUQwhE1yv99QSm1Aez4gcdXwaGdPukeJNcudszlOBNIrlFJrtFkMdfuHXE5/vc3QgghRidLEEII4YgUsBBCOCIFLIQQjkgBCyGEI1LAQgjhiBSwEEI4IgUshBCOSAELIYQjUsBCCOGIFLAQQjgiBSyEEI5IAQshhCNSwEII4YgUsBBCOCIFLIQQjkgBCyGEI1LAQgjhiBSwEEI4IgUshBCOSAELIYQjUsBCCOGIFLAQQjgiBSyEEI5IAQshhCNSwEII4Yg/yjfnVWALlK9Ulosa0CWyodrpa5LrnXbL5TITQJv6prV29u3HJdfOJNdospjrYh0xUgEXKHNUPZT+i1Kgth+grQFr31/Kd/GUffS95brQVch4SbkupL3z/2ySy5Rq91zvKdM5V+D8fct+ffF957rQZcp42XNd6H1kvKK5LjTiPLxquc55j+fwque60C4ZL9YRIxXwm3+O76OKRXS5BJ6H7fUxnS52GF3Kb3dFqFweXSmjSkVIkjRjr4eNY9fRUkqhgwBVKaOCABsNsd0uZhBe1iK+ZNpDFwtpPt/HDgbpGEfRFb/ZvlfK99MxLhYBsP3teZihMVb57XlYKGDjGNvpYvqDbIwxpONcCFDlMiqfw4ZhmjEMszXOpVJ6LX9A+sZ0e9h+/13n4ugFrD30eBVzeA/NayokOUXlbEj+xBrJ+mYmTorK5fHmZoiunaezN0DHlrGTXfTJsyT1pvvJrxS6WETtnad/7Qz9aY+gZSifqKOXVjGdjtvJrxRetYI9uIf2h8cZlhTl1SGFE+skq+vYMHSX7VxE30dPTxF/aA+dg2kBV0738d9YwWzVMlHCKp/HW5hjcO0c3YUcuZ6l8noT7/QKSbPlvuCUQpdLqP0LdK+dJKxqilsJxROb6LNrmH7ffcZzfXPNXtrXlDF+9vvGG1oqJzvoUytp31ykbkYuYJ3PwfwMa0fHad/Xo1QKaTw3yf5kjly3S9IcOi8PXSwwPDzH8seL+HfV6fcCeo9X2dMfors9zMB1AWt0dYzOR2dZekgzdW2N00sT7PnuNJOd/nu6c17ReH4OZqbYvGuSrU9ETE63OfPiNPvVHIVujyQDT8EqCDD7Z1m5r0xytAVA+6kq+6JZVBaegpVCj1XoXzfH0r/NM3bTFutbY0x/b5LZXojq9p2Xh/I89MQ49dumWbnfMLO/xukTU+x/dJZKp5f+NGbdXis6n4OFWdaOVunc26NYCmk+M8n+eA6/3SGJM9A35SLRNXMs3V8kd0edXi9g7LHxN/uG/u6/fPS3IHI5hlMlWtcaHr79n/nyrV/F3tSmPx9AEJxfA3FFaSgW6M8HxDd1+PKtX+X37niE1nWG4VQJcrl0rcZlRM+DUpH2fo+P3r7IX9/8d3zqzmO0D2rsWLqs4zRfzseMl2hfA79+x5P85c1fYerWDbp786hCIQNjnP5oH84U6dwQ8Ue3fZM/uu2bdG6ICGeKqHze+RijNKpQoLs3z9StG/zlzV/h1+94kvY1YMZLqNwlrf5dXp6HHSvRPqj51J3H+Oub/46P3r5Ie386P5XjeYhS5/vmOsPv3fEIX771q8Q3ddK+KWZhLmoIAvrzAfamNl++9as8fPs/07r2gr65iNFngTHoKCHXUTzTPkwtrhA2C/gDA0mSLj67ZNMc3sAwbAU81rmBpXASv6PQwwTMld8wfK8Z/T6caUzwve4NvNqcw+8BcQLGcT5jUMMEv6c41trLuN9jq1FhbmDTMc4Ca/Aig27nebJzLQC67eNFkfs5eE6S4A8s640KP+hdz7HWXvyeQp2bh64ZC3GC34NXm3N8r3wDZxoTBH0yci3btG+GCX5H8UznMGvDcYatAC9jfeMPDGGzwGOdGzjZnyHXUejo3cd55AK20RB/rcHscyUeS27jewXLzKtQXKxjexlYM7IW2+tTWmwx+8QUf7P1IF6omHshwV9tkERDt/kAmyTYVoeJV3usf3uSL73y8xQ2FXMvhVBvYR2XnI1jvI0GMy+McVxfz/PV6xg7BWOvtzCdbgYmvcX0B+SXGsw9Pcc3u3cDMPeiJb/USDe5nM9Dg+l0GXu9Tf/7Vf776c+QbylmXxiiNxokrpdISOch9RZTL02wXtzHl2b2Ul5WTLzaxbY6zuchbPfNaoO5Z4t8J76TJLDMvgKlxVqm+qa42GbmiUn+ZvNBvIFi9oUEf+3d+2b0Ao6HmI0tqs9C+cw41td4Wx1Y2yQZuN+cATCDEO/MCjPRkMmXyihj8TaamI0tbOy+gLEW027jv7rE3uYMcbWA14vQazWShvtNQpskmHqD8vOawsokNvDwmn1Y3czGxgxgowi7usHUDxPGT1QB8DZbmM1a+qaGa9Zi+330G2dZ6EXM/riIChO89Tqm3shEuWESTKNJ4aUl9m9NkZTy+K0BrG1i2u1sjHM8xKxvUn3GUj49jtUKr95NM2apb06fZTaMmDpeQcXmPffN6EsQ1mL6fezZNdTGFkopTBxn6vUkTELSbqPCEH3WB2tJhnF6MjKS0cYxSa2B7nTxPA+ShCSO3W8eQTrGYYhdW0fVG+fHeBg7vzm8yVpMp4MdhKj1TQCSaJi9MW62UL0e2t+eh1GUlm9WMg4jks0tVKOJ53npzTcaZmucf4r75tJ2AqzFDiPnu7gXZW36TmMGXpnalUncv5GxG2vT91azcEPYzQdhHpoEGyaZnocyzpfBJfaNfBaEEEI4IgUshBCOSAELIYQjUsBCCOGIFLAQQjgiBSyEEI5IAQshhCPKjvAys1JqA9jxA4+vgkM7fdI9SK5d7JjLcSaQXKOSXKPJYq7dO2KUAhZCCHH5yBKEEEI4IgUshBCOSAELIYQjUsBCCOGIFLAQQjgiBSyEEI5IAQshhCNSwEII4YgUsBBCOCIFLIQQjkgBCyGEI1LAQgjhiBSwEEI4IgUshBCOSAELIYQjUsBCCOGIFLAQQjgiBSyEEI5IAQshhCNSwEII4YgUsBBCOCIFLIQQjkgBCyGEI1LAQgjhiBSwEEI44o/yzXkV2ALlK5XlogZ0iWyodvqa5Hqn3XK5zATQpr5prZ19+3HJtTPJNZos5rpYR4xUwAXKHFUPXZ5UI3rKPrrr1yTXO+2Wy2UmgG/Zry/udFxy7UxyjSaLuS7WEbIEIYQQjkgBCyGEIyMtQbyF9lCel/6zNdgkAWsvU6zLQKk0n0rvMTZJwCSOQ73NuYyeB8Zi42G2zuG5MdYKkiR7YwxvmYcfiDHOakY/94EZ55+mvrmkAla5PHpiHMYr4HmoTg9Tb2D6/WycFKXQxSJ6vIqtVsAYaLQxrRY2DF2nS2kPr1JGTY5jCwEqGmLrDUyni41j1+nSMa5WUONVbM5HdfvbYzzIRoEohQ4C9MR4OsaAanUwjSYmDLMxD7WHLhbQkxPYchE1jLHNFqbVwQ4j1+kAUL6PrpRRkxPYfA41CLH1Jkmnm41xBlQQoKtVmBgDrdNxbray1zeTE9hKCZIEmulcfLdxHrmAle/jTU8yuHE/9RvyJIFi/FRM5ScBemkFMxhc8t/jclH5PHphjvatczQP+eghTL0ySeGlZZKNTfcFpxS6XMIe3kvtlgl685qgbpn+SRV9Yomk0XA7sbSHHh8jvuEAtRuLDCuKyrJh/FgJvbiciYmv/Bx6dobuzXtoXJsDYOLEFOWfrGBX190XnFLoQoA6uJfGLdN09mlyHcvUSxP4r5whqTXcF5xS6LExzLX72bq5QjipKK0ZJo+V0SeXMZ1OBsbZx5uaZHDjPmo3BJgcjC9OMfbCOnZ5JRMPVDoIUHvnad88S/OwjxdaJl+JKLy0RLK5BcPdf+3oBZzPYxamWTsSMPPgWeZKbZ55+joOdaYo1Jvg+ulDKXSpxOCaac5+THPn0VfY6FdY/fY+DtSmUc2W8wJWnocer1K/cYL1T0d84vrX+OGZw1hdYX5rHNXpOi0QlfNhdor1O0t4n9rktplVfvD8R/DCSSq1JgxCsA7LQylUIWB4YJqVe3yu+9hJAF77wWEONafxGk33yzlKo8YqdK6f5OyDho/d9hIvbi6wXphhb20K1e5gQ7cFrPwcanKczVsrdH+uw88eOMX3Xr0OnUwwWWtj+33310o+T7IwzeqRgLkHl5ktdnj2qes41J4mqDdJosh536hyicHhKZY/rrnryCus98ZY+/betG9a7YsW8OibcJ5HXMnTXzD8xsEneHjfIwQHO0QTPvj+m2sgzigN+RzhhE/uYJeH9z3Cbx58jP6ehKSaR/k+qB1fybvqGftTmtsPn+H39zzCJ695mcGswhaDdC3OZTzPw5QD+vOWXz78HL+75x/Zd3iTwYSHyudRjvNB+mQ0rOaJ9g357f3f5rf3f5to35DhuTF2nU8rVD7PYMJj3+FNfnfPP/LLh5+jP28x5eD8eqZLOp1vg1nFJ695md/f8wi3Hz5Dfyqdn+6vZYXyfZJqnv6ehN88+BgP73uE3MEu4YSfkYwafJ9owic42OHhfY/wGwefoL9giCv5dO3/IkafqUmC34korpT4X4v3MldqEy1WyDeGEMdgzaX+VS4PayAaEjRihotl/mThM2z2KxRXPLxWlN7RXa8bbWcsbhl+fPIAf5j7DD9aOkRl3aL6IRi3+WySoLshxbUq/+fUHRyb3sfyqRkO1hJsFGEd5wOwcUyuFREslfjSmfT9zmApR67Vc/7UBmCNxUYRxVrC6VMz/HH1MxzfmqO4ptDdEJNkYH3VpPOtuG7555MfoTEs8uOTB1jYSuen+2vZYuMYrxVRXCnyV4sfY6bYYbhYJmgMM5LRQByTb8REixX+ZP4zrPfGKK5o/E6UrgdfxMgFbKMIb3WLhacL1JoLNIM97F2MKb6xhen2MlBuFtPrUTi5xd4fzHHi9PXooWXhlRBvdSv9kcUxmySYZovx4w2sN8HzP76Zsbpl6sUOtlZPf3x2mW8Yw0aNuWfL1PrTHKvMsHc5oXyihm13MjDpLXYQkjuzxZ4n8qysHwZgz4khuTNbJIMMbMJZg213KJ+os/fRKY69fCO5jmXueA82auk5dszGQ2ytzvSxMZSp8PzkzcyvGcaPNzDNVrqT7zrjub55qkC9sYdGTrF3MaZwcoukl42+sd0exTfSvnnt9PV4oWXhlQH6PfTN6AUcxyRbdfLHYhbOVNNdyXY33ZXMwII4pINmVtcZ6w+oHC+nb0E0OyQt9+u/aUCL6fbQJ5eZanaZLASoMMI2mphO1/2kMgmm2cZ/+TTzK297CyIL5UZaHmZjk+JzEcXX07cg2N4dd30DA9IxHoTo02eZaPcYf9tbEM434M5l7HTRr51mdmMcG+RRgxBTa2TjYYrtvqnVCY4lLJyuvKVvbAYepoC09871zUvbfdNokTTb79o3l7RYZocRSa2Bara3D2TsvTxrMf1+OkCbtfRQ1t6/NAmm08H2++k6UsbOoR1GJPUmqtXZPpCtfGnBDSAaomqN9FAWx7jXS3fqM/o+uo1jkmYL1elmch4C2DAk2aqhGs3tAxnL+D765tJ3K0yCzdBEeoft9aNMy3rGrI8xZD9j1scYPhgZf0rHWf5TZCGEcEQKWAghHJECFkIIR6SAhRDCEWVH2ElUSm0AO37g8VVwaKdPugfJtYsdcznOBJJrVJJrNFnMtXtHjFLAQgghLh9ZghBCCEekgIUQwhEpYCGEcEQKWAghHJECFkIIR6SAhRDCESlgIYRwRApYCCEckQIWQghHpICFEMIRKWAhhHBEClgIIRyRAhZCCEekgIUQwhEpYCGEcEQKWAghHJECFkIIR6SAhRDCESlgIYRwRApYCCEckQIWQghHpICFEMIRKWAhhHBEClgIIRyRAhZCCEf8Ub45rwJboHylslzUgC6RDdVOX5Nc77RbLpeZANrUN621s28/Lrl2JrlGk8VcF+uIkQq4QJmj6qHLk2pET9lHd/2a5Hqn3XK5zATwLfv1xZ2OS66dSa7RZDHXxTpCliCEEMIRKWAhhHBEClgIIRyRAhZCCEekgIUQwpGR3oJ4k1IoP4fK+aAUNo6xwxhMcpnjvQ9KofJ5lO+DtdhhjI2HYK3rZOdpD53PgeelGaMIG8euU6WUQnkeKp8HpSBJMNEwe2Ps51D5HAA2Gn4wxjhJMpVR+f4HY5wv7JsoytQ5RHuonD9y34xewEqhi0X07DTJ7DjW13i1LqxvkrQ62Rg47eFVyjA/QzJdQcUGb6OJ2djC9PuZGDjl++jJSez8NMlYgNeL8NZqJPUGNgwdh1PoIEBPT5HMTWIKPn6jh7e+hWm2snGTUApdqaBnp4lnxgDwN9vpGHc62Rnj8SrMTRNPlNCDGG+9jtmqYcIwGxmDAG9yAjM/RVLK47VDvLUtTL2enXF+e99sdWBtk6TTzU7fVCswN0MyVd6hb3b/pSMXsPJz6NlpWnftZfNWj6RgGX+1zMzTOfQbpzG93vv5q1wWuhDAgT1sHJmieQPoUDHzQpnxZxR2eRU7jNwGVAo9NkZ83V7WfqZMb5+lsFlm7l9KBMcMyVbN6cRSnoeenqJ72z7W78gxHLeMnSwx93Qe/VpM0m47Lw8dBKiFWWo/M0ftpvQd96kXy0z+SKPPDDGDgdN8KIUulTCH97B+pEr7Gsg1FXPPlSg/D3Zt3X3BaQ9drTK4cT/r/yZgMGMpLZeZ/1GAfzwmaTScj7Pyc+i5GZp37WHzVg8TWMZfKTP7dA598kxm+sbu38PmkUma14M3SPum+gzYs2twkboZvYDzOeL5Cdbv0Nz/6ef4UHGTv5j5BOW1MUqrRXD9hKkUqlSkd6jK5t0xn7v7uywOpnnUu4Py8gR6Y8t5ASvPQ1UrNK4voR+s8V+ue5xvnL2DWm8/e5aqqEYT67KAfR8zXWXz1hw3f+YVPjZ5gv/2wv0Ut8aYOFuCTheswycPpVCFgGj/BOs/A//h/scB+FrpHsorE+Q3tsD1E6bSqHKJ9ofH6Hy8x3++9bv8oH4tLyU3UFyqorZqzgtYeR5MVqndGDD3qSV+ce9z/M/X7qXRnGR2uYJqt91nzOeIFybYuEPz0Kef5VBhi7+Yup/yWpXSWpb6ZozNe4Z87uj3eKM/w3e92yktTaA3axct4NE34bTG5jzisuWOymmOll4nqIbEBZ2ucynH+3pKg9IkBU2uGnK09Dp3VU4RVywm54HW6VqX64yeR1yEfeNN7i2e4NrqBnEJ8D3QjvOdG+OS5aaxFe4pvcbUeJc4UOkYZ4HSJHmNGYs5UnmDI5U3MGMxSV67n4PneB5xoJga73JP6TVuGlshLlnsuXnomlbge8QluLa6wb3FE+wbbxIXyci1rEBrTM4jrljuqpziaOl1ctWQpKDfvNbdZty+lguaYLtv7qicJi6/t3EefQ14OMSv9xh/rcifzn+KYilE/WSM0mpv+6nDXOpf5fKwBsKQ4lqI/2KF3wl+hX4/T/U1Ta7Www7db9LYJIFen7GlhOPPHeI/tn+N2vIEexYNqt2DxO26lh3G6GaP6htV/ubZu/nm1K10X5pk/0qEHQwyMMbpZlaw2afy8ji/P/4LAFRezhNsNrOxQWMNdjCgvBKx9Pwsvzn8LI1amdk3QDd7mGEG1leTBNXuMbZo+Kdnb+Ff9h2gcWKK/Uvp/LSO5yHWwnBIrtaj+lqRP577OYrFCP/FCsW1bPVNaTXtwd/J/Qr9XsD4awq/vt03FzFyAZtoiLe2ydzTOUrrFUwuoLzcJ3dqnaSbgQ0uazH9Abk3Vtmn99B9rcp4bKmcbMLqRrrD65pJMK025eMbHBzOMPjRFAdbhvLrW5ha3fnEt/EQ1reYfjag0KgyLE0wtRZROLFO0s7GBpcNQ/TSBnse9+meTj9kpXymi17aSDe4XLMW0+5QfG2dA3aO3rEJDvQM5TfqsL6VnmPXEZMEU6sz8UKRXHeSqDrFwVpC8cQmptXOxAaXiYZ4qxvM/9CnvFbB+IW0b95YJekP3M9FazHdtP/2f2ee7qtVxoeWyqkWrG2+a9+M/gRsEkyzhXp1yPhyKX0tZBCSdLrO11bPscOIZLNGbhAyeSLYPkm9dEcyA5MKwPT76KUVio0WpSBIX6HqdjGDDOyOW0vS6aJfP0NlrYzyfexgkI5xlJExjmPMVg2/P2DiVCk91u1hej3n65bn2CgiWV0n6HQpFArp61OdbjaKA958WNGLy5Q3G1TyOWwYYjvdbNzE4IPTN+ub5Hr9kfvmkt4DTidSB9Pd3oG0JhsT6gJ2GJE0hufXiLKW0dp0pz4Mz2fMyM0BSCd+rwf97bcJsnb+SOdh0m6nm4KQvYzWYsOQJIqyOw/PjfNgu3Czlo+f7r65tP8QA9Lf3OVO+HshGd+fLGc7RzJeHlm6+e/kg3AOLyFjBrZihRDiXydlR3iUV0ptADt+4PFVcGinT7oHybWLHXM5zgSSa1SSazRZzLV7R4xSwEIIIS4fWYIQQghHpICFEMIRKWAhhHBEClgIIRyRAhZCCEekgIUQwhEpYCGEcEQKWAghHJECFkIIR6SAhRDCESlgIYRwRApYCCEckQIWQghHpICFEMIRKWAhhHBEClgIIRyRAhZCCEekgIUQwhEpYCGEcEQKWAghHJECFkIIR6SAhRDCESlgIYRwRApYCCEckQIWQghH/FG+Oa8CW6B8pbJc1IAukQ3VTl+TXO+0Wy6XmQDa1DettbNvPy65dia5RpPFXBfriJEKuECZo+qhy5NqRE/ZR3f9muR6p91yucwE8C379cWdjkuunUmu0WQx18U6QpYghBDCESlgIYRwRApYCCEckQIWQghHpICFEMIRKWAhhHBEClgIIRwZ6T3gd1AXvFts7fuMcgVkPR9kP2PW88H5jFnPB5Lx/ch6xkvId2kFrD10IUAVC6AUNoyw/T42ji/pt7sSlO+jikVUkAdrsf0BZhCCSVxHSymF8nPoYgHyOYhjTH+AjaJsTC6l0EGAKhbB0xAN03zDyHWy87SHLhZQhQAAOwgx/UF2xhhQufz5MU4Mtt/HhGE2xhjSeZjfzuj758c5HmYn409x34xewNrDq5Rh/wL9A1Wsryis9dGLa5h6PRMnRfk+enISc2ie/nwRFVuKS2285VWSVicTF6jK5/HmZokOzRBN5sm1Y4LFLczaBqbfdzv5lUKXSqh9C4QHJoiLHsFWSO7UGslmLRslrD28yXHs/nl6eysAFM928JbWSOrNbIxxLo83M8Xw8DzhdIDfTwjONNDLq5hez33BKYUuFtHzs4SHphmO+eTrEfnFTZL1DWwYus0H6ThXK7Bvgf7+sQ9O35xp4S2tknS6cJGpOHIBq5wPC7NsHplm42iCKiaUf1Jl7/cVejDAdjrOy0MVi5jDC5z9+BidW0LswGPm6SlmH09Q/QE2dHxxag9drdL/6ALLH8sRXzNAny2w54l5xn40xEaR04ml/Bx6dpr6nbOs3g1qKiR4ucy+7+8hNwhJGu6fjnQhwO6bY/XeSRp3pjeEiWcnWXjMovuDtOBcUgpdKRNdu4fljxcJP9LH1gIWnpxlMhpil4fOb2TK89CTE7Rvm2flHg+zd4B/ssi+HyxQGIQkWzXnNzKV82F+lo2jU2weSVCFhMqxtG9UhvomuSbtm+7NIbbvMfvUNDNxgloML1rAI2/CqXyeeKZC/Ub43H3f4Yv3fo3+nT16+0qoUhGU4309pVGFAr19RXp39vnivV/jt+57lPqNlnimgsrn37pW4ySiQlVKNA/n2H/3Mn99999y9L7jND7sY6tl8Dy3+XI+yeQY9Rs0v3Df0/z53V8hOFKjfTBAlUsZGGOFCgLChQqNW2P+4N5/4A/u/Qcat8aECxVUEDgfY5RGlUu0DwYER2r8+d1f4Rfue5r6DZpkciwtFtc8D1st0/iwz9H7jvPXd/8t++9epnk4h6qUUNr1OVQX9I3lt+57lC/e+zV6d/bp7SuiCoUMzEWNKhXp7SvRv7PHF+/9Gp+77zvUb+R831zE6LPAGLCgDLSTAq2kgE0UylgwGVgzsgYAlYCJFY2kRC8JUIk6f6d0/aPfNmUgjH0apkQvzqGM60TbjEFZi0qgkwS0TZFh4lEwZObcYQ0qsahE0TYFAFSiUIl9cw44Zy3KwDDxaJsinSRAJaCsTa+jjFAGenGOhikRxn525uEF16tKFL0koJGUMLFCnXuqzMJYG4syFpsoWkmBdlJIz6HlXcd55AK2cYy/0WL6hSL/O3cvSdEw8ZJPaamJHQwycUJsr0dxqcv40+N8ofvv0QPN7DGLv97CRO7XL62x2HaHiddDVr6/wOcXf5VgzWfhlSGq3oLE7Y99No7xtlpMHR/j25Xb+aeJW6ic8Blb7GK7XfdjbC12EBKstJl6dpovJZ8GYOp5TbDSxg4ysMllDbbbZWyxT+eJcR5e/xX8hsf88QS91SLJwNolSYKqt5h8ZYKXvnstn58/TGkxx57XB9h2B5uBByobRfjrLaaPFfm73McxBcPEiz7FpSbW9TITpOM8GFBa6lJ9apz/2v5FvL5m9gWLv9HCvMs4j17AUYRd22TyR4rK8jjG1+Q3WqjldfebR5BenGGIPr3CQpIw9XIZlcTkzzaxa5vpWwaumQTTbBO8fJYDnVmi8Tx+t0duaQvTaDrfWLBJgtmqMf6sR3FtkqTgkd/qos9uYDpd92MMmGiId3aNuSdh4o10Ey6/1oGza5ho6DgdYC2m08V/fYV9/VmiHxfwBhH55Tpmq4Z1fJOF9EZrGk3Kx1Y4WJ8mLvvkm228pQ2SZtv5+i+c75uppzWVpXGsp873TRbeJrEW2++jT62wMEyYOl5Gx0Ny77FvRl+CsBbT6aDPDMltbKWHoiFJhl7xsnFMUm+i+wOC07n02CDMxoBts8OIZGMT1elS8P008yBMX/9xzVpMv489u0puq07O87BRhAlD5zeHN5mEpNVBD0LyZy94DS0aZmoemq1aOsb5PCQJSRhm51VDSMd0dR2v0cQ/Nw+z9IrXub45PSS/vpke+inqG2VHmAhKqQ1gxw88vgoO7fRJ9yC5drFjLseZQHKNSnKNJou5du+IUQpYCCHE5SOfBSGEEI5IAQshhCNSwEII4YgUsBBCOCIFLIQQjkgBCyGEI1LAQgjhiBSwEEI4IgUshBCO/H+OYuOJkF7DEwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] }, "metadata": { @@ -202,71 +154,44 @@ } ], "source": [ - "# TODO: prettify the plots\n", - "f, ax = plt.subplots(n_channels[1], n_channels[0])\n", + "plt.plot(basis_centers[:, 0], basis_centers[:, 1], '.')\n", + "plt.title('Centers of all basis functions')\n", + "plt.xlim(stimx)\n", + "plt.ylim(stimy)\n", + "plt.show()\n", + "\n", + "f, ax = plt.subplots(n_channels[1], n_channels[0], figsize=[18, 8])\n", "i = 0\n", "for ii in range(n_channels[1]):\n", " for jj in range(n_channels[0]):\n", " ax[ii, jj].imshow(basis_fcns[i, :].reshape(stim_res[1], \n", - " stim_res[0]))\n", - " ax[ii, jj].axes.get_xaxis().set_visible(False)\n", - " ax[ii, jj].axes.get_yaxis().set_visible(False)\n", + " stim_res[0]),\n", + " extent=[stimx[0], stimx[1], stimy[0], stimy[1]])\n", " i += 1\n", + "plt.suptitle('Images of each basis function', fontsize=25)\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO: show summed together basis functions\n", - "# TODO: show cross-section of summed basis functions to demonstrate they are flat/smooth" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(128, 45)\n" - ] - } - ], - "source": [ - "# nobs = 100\n", - "# sx = np.linspace(-6, 6, 10) #np.random.randint(0, high=12, size=(nobs, 1)) - 6\n", - "# sy = np.linspace(-3, 3, 10) #np.random.randint(0, high=6, size=(nobs, 1)) - 3\n", - "# sxx, syy = np.meshgrid(sx, sy)\n", - "# ydata = np.hstack((sxx.reshape(-1, 1), syy.reshape(-1, 1)))\n", - "\n", - "C = iem_obj._define_trial_activations(trn_conds)\n", - "print(C.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 48, + "execution_count": 77, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -278,49 +203,76 @@ } ], "source": [ - "plt.imshow(C)" + "sum_fcns = basis_fcns.sum(axis=0).reshape(stim_res[1], stim_res[0])\n", + "plt.imshow(sum_fcns, extent=[stimx[0], stimx[1], stimy[0], stimy[1]])\n", + "plt.title('Spatial coverage of basis functions')\n", + "\n", + "plt.figure()\n", + "plt.plot(iem_obj.yp, sum_fcns[:, 51])\n", + "plt.title('Cross-section of summed coverage')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TODO: Explain the predicted channel responses / what I've called the trial activations in the channel domain" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 78, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(653, 45)\n" + "(128, 45)\n" ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "# nvox = 1000\n", - "# X = np.zeros((nobs, nvox))\n", - "# for i, l in enumerate(np.linspace(-1, 1, 10)):\n", - "# X[i*10:i*10+10, :] = np.random.normal(loc=l, scale=1.5, \n", - "# size=(10, nvox))\n", - "iem_obj = iem_obj.fit(trn, trn_conds)\n", - "\n", - "print(iem_obj.W_.shape)" + "C = iem_obj._define_trial_activations(trn_conds)\n", + "plt.imshow(C)\n", + "print(C.shape)" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 79, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(17271, 288)\n" - ] - } - ], + "outputs": [], "source": [ - "stim_reconstructions = iem_obj.predict_feature_responses(tst)\n", - "print(stim_reconstructions.shape)" + "iem_obj = iem_obj.fit(trn, trn_conds)\n", + "stim_reconstructions = iem_obj.predict_feature_responses(tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TODO: re-write text to be in our own words!\n", + "\n", + "## Combine non-like stimulus feature values\n", + "One of the biggest advantages of the IEM technique is that by transforming activation patterns into a \"feature space\" (here, spatial information channels), you have full knowledge of how your activation is related to feature values. Put another way, you know how to manipulate your feature space in order to coregister non-like trials. For example, here, we don't necessarily care too much about what may or may not be different in stimulus reconstructions computed from trials in which stimuli were on the left compared with trials when stimuli were on the right.\n", + "\n", + "Accordingly, we can average these trials after \"coregistering\" the reconstructions. Fortunately, this is an easy dataset to coregister. We just need to flip the reconstructions across the vertical meridian for one half of trials [sorted by trn_conds[:,1], which is the stimulus side]. It doesn't matter whether we flip left trials onto the right side of the screen or vice versa. Try it below!\n", + "\n", + "So that it's easy to \"flip\" the reconstructions, let's turn our reconstruction matrix, in which each reconstruction occupies a row (n_trials x n_pixels), into a reconstruction 3d-matrix in which each trial is the 3rd dimension, and each \"slice\" is a single-trial's stimulus reconstruction. It's easiest to make trial the 3rd dimension so that we don't need to \"squeeze\" the data later on." ] }, { @@ -346,6 +298,13 @@ " mean_recons[ss, aa, :] = rs.squeeze()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# TODO: interpret the plot below for the reader" + ] + }, { "cell_type": "code", "execution_count": 52, @@ -382,20 +341,6 @@ " if attn_cond == 1:\n", " ax[ss, aa].set_ylabel('Contrast value {}'.format(contrast))" ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# X2 = np.zeros((5, nvox))\n", - "# for i, l in enumerate(np.linspace(-1, 1, 5)):\n", - "# X2[i, :] = np.random.normal(loc=l, scale=1.5, \n", - "# size=(1, nvox))\n", - "# pred_vals = iem_obj.predict()\n", - "# print(pred_vals, pred_vals.shape)" - ] } ], "metadata": { From 3057edf27f9fc0d62350b65962a1403d20436fe2 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Fri, 2 Oct 2020 13:51:56 -0700 Subject: [PATCH 16/39] resolving TODOs with suggestions from JA, with some edits --- examples/reconstruct/iem2d_example.ipynb | 40 +++++++++++++++++------- 1 file changed, 29 insertions(+), 11 deletions(-) diff --git a/examples/reconstruct/iem2d_example.ipynb b/examples/reconstruct/iem2d_example.ipynb index 476dd1ebd..520a53fdf 100644 --- a/examples/reconstruct/iem2d_example.ipynb +++ b/examples/reconstruct/iem2d_example.ipynb @@ -43,7 +43,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# TODO: explain the test data & conditions" + "The test data have different conditions than the training data. There are four independent variables in these data based on the values in the following columns: \n", + "- In column 1, whether the stimulus was on the left (1) or right (2) side of the screen. \n", + "- In column 2, the logarithmically spaced stimulus contrast from lowest (1) to highest (6). \n", + "- In column 3, the task instruction to attend to fixation (1) or the stimulus (2).\n", + "- In column 4, whether the target was present (1) or not (0)." ] }, { @@ -217,7 +221,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# TODO: Explain the predicted channel responses / what I've called the trial activations in the channel domain" + "Next, we want to map channel responses for each voxel. To do this, we fit a standard general linear model (GLM), where the design matrix is the channel activations for each trial. Below, you can see the design matrix of these trial activations in the channel domain (x-axis: trials, y-axis: channels, color: activations)." ] }, { @@ -251,6 +255,13 @@ "print(C.shape)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whenever you run the fit() function, the trial-wise channel activations will be created automatically, and the GLM will be fit on the training data and feature labels. Using this, we can then predict the feature responses on a set of test data." + ] + }, { "cell_type": "code", "execution_count": 79, @@ -265,14 +276,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# TODO: re-write text to be in our own words!\n", - "\n", - "## Combine non-like stimulus feature values\n", - "One of the biggest advantages of the IEM technique is that by transforming activation patterns into a \"feature space\" (here, spatial information channels), you have full knowledge of how your activation is related to feature values. Put another way, you know how to manipulate your feature space in order to coregister non-like trials. For example, here, we don't necessarily care too much about what may or may not be different in stimulus reconstructions computed from trials in which stimuli were on the left compared with trials when stimuli were on the right.\n", - "\n", - "Accordingly, we can average these trials after \"coregistering\" the reconstructions. Fortunately, this is an easy dataset to coregister. We just need to flip the reconstructions across the vertical meridian for one half of trials [sorted by trn_conds[:,1], which is the stimulus side]. It doesn't matter whether we flip left trials onto the right side of the screen or vice versa. Try it below!\n", + "## Average feature reconstructions across trials\n", "\n", - "So that it's easy to \"flip\" the reconstructions, let's turn our reconstruction matrix, in which each reconstruction occupies a row (n_trials x n_pixels), into a reconstruction 3d-matrix in which each trial is the 3rd dimension, and each \"slice\" is a single-trial's stimulus reconstruction. It's easiest to make trial the 3rd dimension so that we don't need to \"squeeze\" the data later on." + "In this experiment, we are not specifically interested in separating trials by whether stimuli were on the left or the right. Instead, we're interested in how the activation in the model-based reconstruction varies with the experimental manipulation of contrast and attended location. For the sake of visualization and quantification, we can simply average across the trials of interest. Below we're separate the trials by contrast and attention location, but average across trials where the stimulus appeared on the left side of the screen and the target was not present (to ensure that overall contrast is identical across averaged trials)." ] }, { @@ -302,7 +308,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# TODO: interpret the plot below for the reader" + "Finally, we plot the data as a function of:\n", + " \n", + "1) whether subjects were attending to the stimulus or fixation, and\n", + "2) the contrast of the stimulus (across six levels)" ] }, { @@ -341,6 +350,15 @@ " if attn_cond == 1:\n", " ax[ss, aa].set_ylabel('Contrast value {}'.format(contrast))" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These data suggest that increasing the contrast leads to stronger activation of the stimulus. They also suggest that the effect of attention is greatest at low contrast levels -- e.g. at contrast level 3, we see a clear enhancement when the participant is attending to the stimulus compared to when they are attending fixation.\n", + "\n", + "However, since this is single-participant data, these effects should be quantified across a group of subjects." + ] } ], "metadata": { @@ -359,7 +377,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.3" } }, "nbformat": 4, From 0e9b8d330a34d54467f7a59272c85b26ab6ebb35 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 10:51:14 -0700 Subject: [PATCH 17/39] adding parameter checks and corresponding tests. still need to finish expanding tests for 2D case --- brainiak/reconstruct/iem.py | 19 +++++++++++++------ tests/reconstruct/test_iem.py | 21 +++++++++++++++++++-- 2 files changed, 32 insertions(+), 8 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 0ac27616c..a34a70ea5 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -558,18 +558,25 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, self.n_channels = self.channels.shape[0] self.channel_limits = [chan_xlim, chan_ylim] self.channel_exp = channel_exp + self._check_params() def _check_params(self): + if len(self.stim_fov[0]) != 2 or len(self.stim_fov[1]) != 2: + raise ValueError("Stimulus limits should be a sequence of 2 values") + else: + if (self.stim_fov[0][0] >= self.stim_fov[0][1]) or \ + (self.stim_fov[1][0] >= self.stim_fov[1][1]): + raise ValueError("Stimulus x or y limits should be ascending values") if self.n_channels and self.channels and \ (self.n_channels != self.channels.shape[0]): raise ValueError("Number of channels {} does not match the defined channels" ": {}".format(self.n_channels, self.channels.shape[0])) - if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ - any(self.channels[:, 0] < self.channel_limits[0][0]) or \ - any(self.channels[:, 1] > self.channel_limits[1][1]) or \ - any(self.channels[:, 1] < self.channel_limits[1][0]): - raise ValueError("Channel limits and values defined in self.channels do not" - "match each other.") + if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ + any(self.channels[:, 0] < self.channel_limits[0][0]) or \ + any(self.channels[:, 1] > self.channel_limits[1][1]) or \ + any(self.channels[:, 1] < self.channel_limits[1][0]): + raise ValueError("Channel limits and values defined in self.channels do not" + "match each other.") def fit(self, X, y): """Use data and feature variable labels to fit an IEM diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 521a9a6ae..fd64a0be4 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -15,7 +15,7 @@ import pytest import numpy as np import logging -from brainiak.reconstruct.iem import InvertedEncoding1D +from brainiak.reconstruct.iem import InvertedEncoding1D, InvertedEncoding2D from brainiak.utils.fmrisim import generate_1d_gaussian_rfs, \ generate_1d_rf_responses from scipy.stats import circmean @@ -27,6 +27,9 @@ def test_can_instantiate(): s = InvertedEncoding1D() assert s, "Invalid InvertedEncoding1D instance" + s2 = InvertedEncoding2D(stim_xlim=[0, 0], stim_ylim=[0, 0], + stimulus_resolution=[0, 0]) + assert s2, "Invalid InvertedEncoding2D instance" # Simple test for checking range values. @@ -35,21 +38,35 @@ def test_instantiate_improper_range(): s = InvertedEncoding1D(6, 5, 'halfcircular', range_start=20, range_stop=0) assert s, "Invalid InvertedEncoding1D instance" + with pytest.raises(ValueError): + s2 = InvertedEncoding2D(stim_xlim=[0, -1], stim_ylim=[0, -1], + stimulus_resolution=[10, 10]) + assert s2, "Invalid InvertedEncoding2D instance" # Test to check stimulus resolution input def test_stimulus_resolution(): s = InvertedEncoding1D(6, 5, stimulus_resolution=360) assert s.stim_res == 360 + s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], + stimulus_resolution=[10, 10]) + assert len(s2.stim_pixels[0] == 10) + assert len(s2.stim_pixels[1] == 10) # Provide invalid data so that channels cannot be created. -def test_cannot_instantiate_channels(): +def test_cannot_instantiate_1d_channels(): with pytest.raises(ValueError): s = InvertedEncoding1D(n_channels=0) assert s, "Invalid InvertedEncoding1D instance" +# Provide invalid data so that channels cannot be created. +def test_cannot_instantiate_2d_channels(): + #TODO: fill in with custom channels but wrong channel number + pass + + # Provide invalid stimulus mode def test_stimulus_mode(): with pytest.raises(ValueError): From 5984dc40d3b1327ae9ebe00abb1a7574d9285bdb Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 14:36:27 -0700 Subject: [PATCH 18/39] fixed docstrings --- brainiak/reconstruct/iem.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index a34a70ea5..0c310fde7 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -750,13 +750,15 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): Parameters ---------- - nchannels: number of channels in the x (horizontal) direction - channel_size: the desired full-width half-maximum (FWHM) of the + nchannels: number of channels in the x (horizontal) direction + channel_size: the desired full-width half-maximum (FWHM) of the channel, in stimulus space. Returns ------- - channel_centers: numpy array of the centers of each channel + self.channels: defines channels, [nchannels x npixels] matrix. + channel_centers: numpy array of the centers of each channel + # TODO: get dimensionality of channel_centers """ chan_xcenters = np.linspace(self.channel_limits[0][0], self.channel_limits[0][1], nchannels[0]) @@ -784,7 +786,8 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): Returns ------- - channel_centers: numpy array of the centers of each channel + self.channels: defines channels, [nchannels x npixels] matrix. + channel_centers: numpy array of the centers of each channel """ x_dist = np.diff(self.channel_limits[0]) / (grid_radius*2) y_dist = x_dist * np.sqrt(3) * 0.5 From 3618223914f35c5f3ebd3044c177de057a303a2e Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 14:36:55 -0700 Subject: [PATCH 19/39] tests on stimulus resolution & custom channel definition --- tests/reconstruct/test_iem.py | 39 ++++++++++++++++++++++++++++++----- 1 file changed, 34 insertions(+), 5 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index fd64a0be4..5a106143f 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -45,13 +45,34 @@ def test_instantiate_improper_range(): # Test to check stimulus resolution input -def test_stimulus_resolution(): +def test_1d_stimulus_resolution(): s = InvertedEncoding1D(6, 5, stimulus_resolution=360) assert s.stim_res == 360 + + +# Test to check that stimulus resolution is used properly +def test_2d_stimulus_resolution(): s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], - stimulus_resolution=[10, 10]) + stimulus_resolution=10) assert len(s2.stim_pixels[0] == 10) assert len(s2.stim_pixels[1] == 10) + s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-2, 2], + stimulus_resolution=[10, 20]) + assert len(s2.stim_pixels[0] == 10) + assert len(s2.stim_pixels[1] == 20) + + +# Test that 2D channels can be set by the user +def test_2d_custom_channels(): + nchan = 8 + res = 10 + npix = res*res + channels = np.random.rand(nchan, npix)*2 - 1 + bds = [-1, 1] + s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=res, chan_xlim=bds, + chan_ylim=bds, channels=channels) + assert s, "Unable to define custom InvertedEncoding2D channels" # Provide invalid data so that channels cannot be created. @@ -61,10 +82,18 @@ def test_cannot_instantiate_1d_channels(): assert s, "Invalid InvertedEncoding1D instance" -# Provide invalid data so that channels cannot be created. +# Test that modifying channel properties is not allowed. def test_cannot_instantiate_2d_channels(): - #TODO: fill in with custom channels but wrong channel number - pass + nchan = 8 + res = 10 + npix = res*res + channels = np.random.rand(nchan, npix)*2 - 1 + bds = [-1, 1] + s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=res, chan_xlim=bds, + chan_ylim=bds, channels=channels) + with pytest.raises(ValueError): + s.set_params({'n_channels': nchan - 1}) # Provide invalid stimulus mode From 63be22e413fa5b18ff7ab3ce6e554c97684fafcb Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 14:55:19 -0700 Subject: [PATCH 20/39] added to check_params() --- brainiak/reconstruct/iem.py | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 0c310fde7..7b8b43dd6 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -567,16 +567,24 @@ def _check_params(self): if (self.stim_fov[0][0] >= self.stim_fov[0][1]) or \ (self.stim_fov[1][0] >= self.stim_fov[1][1]): raise ValueError("Stimulus x or y limits should be ascending values") - if self.n_channels and self.channels and \ - (self.n_channels != self.channels.shape[0]): - raise ValueError("Number of channels {} does not match the defined channels" - ": {}".format(self.n_channels, self.channels.shape[0])) - if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ - any(self.channels[:, 0] < self.channel_limits[0][0]) or \ - any(self.channels[:, 1] > self.channel_limits[1][1]) or \ - any(self.channels[:, 1] < self.channel_limits[1][0]): - raise ValueError("Channel limits and values defined in self.channels do not" - "match each other.") + if self.xp.size != self.yp.size: + raise ValueError("xpixel grid and ypixel grid do not have same number of elements") + if self.n_channels and self.channels: + if self.n_channels != self.channels.shape[0]: + raise ValueError("Number of channels {} does not match the defined channels" + ": {}".format(self.n_channels, self.channels.shape[0])) + if self.channels.shape[1] != self.xp.size: + raise ValueError("Defined {} channels over {} pixels, but stimuli are " + "represented over {} pixels. Pixels should match.".\ + format(self.n_channels, self.channels.shape[1], + self.xp.size)) + if self.channel_limits: + if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ + any(self.channels[:, 0] < self.channel_limits[0][0]) or \ + any(self.channels[:, 1] > self.channel_limits[1][1]) or \ + any(self.channels[:, 1] < self.channel_limits[1][0]): + raise ValueError("Channel limits and values defined in self.channels do not" + "match each other.") def fit(self, X, y): """Use data and feature variable labels to fit an IEM From f64fcfc3ae2c6dc8793a4f648978ee8beb57d2a7 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 14:55:46 -0700 Subject: [PATCH 21/39] expanded 2D tests; reorganized the rest --- tests/reconstruct/test_iem.py | 40 ++++++++++++++++++++++++----------- 1 file changed, 28 insertions(+), 12 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 5a106143f..3e7c663f4 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -44,11 +44,7 @@ def test_instantiate_improper_range(): assert s2, "Invalid InvertedEncoding2D instance" -# Test to check stimulus resolution input -def test_1d_stimulus_resolution(): - s = InvertedEncoding1D(6, 5, stimulus_resolution=360) - assert s.stim_res == 360 - +### TESTS SPECIFIC TO 2D MODEL ### # Test to check that stimulus resolution is used properly def test_2d_stimulus_resolution(): @@ -75,15 +71,17 @@ def test_2d_custom_channels(): assert s, "Unable to define custom InvertedEncoding2D channels" -# Provide invalid data so that channels cannot be created. -def test_cannot_instantiate_1d_channels(): +# Test that channel definition should be consistent. +def test_cannot_instantiate_2d_channels(): with pytest.raises(ValueError): - s = InvertedEncoding1D(n_channels=0) - assert s, "Invalid InvertedEncoding1D instance" + s = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], + stimulus_resolution=10, + channels=np.random.rand(5, 5)) + assert s, "Invalid InvertedEncoding2D instance" -# Test that modifying channel properties is not allowed. -def test_cannot_instantiate_2d_channels(): +# Test that you cannot modify properties in an inconsistent way. +def test_modify_2d_properties(): nchan = 8 res = 10 npix = res*res @@ -93,7 +91,25 @@ def test_cannot_instantiate_2d_channels(): stimulus_resolution=res, chan_xlim=bds, chan_ylim=bds, channels=channels) with pytest.raises(ValueError): - s.set_params({'n_channels': nchan - 1}) + s.set_params(n_channels=nchan - 1) + with pytest.raises(ValueError): + s.set_params(xp=np.random.rand(npix - 10) + # TODO: test with stim_fov? + + +### TESTS SPECIFIC TO 1D MODEL ### + +# Test to check stimulus resolution input +def test_1d_stimulus_resolution(): + s = InvertedEncoding1D(6, 5, stimulus_resolution=360) + assert s.stim_res == 360 + + +# Provide invalid data so that channels cannot be created. +def test_cannot_instantiate_1d_channels(): + with pytest.raises(ValueError): + s = InvertedEncoding1D(n_channels=0) + assert s, "Invalid InvertedEncoding1D instance" # Provide invalid stimulus mode From c01e3c131660fd42371e4e55a301f65ba6018898 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 17:12:28 -0700 Subject: [PATCH 22/39] pytest now runs. added 2d FOV check --- brainiak/reconstruct/iem.py | 16 +++++++++++----- tests/reconstruct/test_iem.py | 27 ++++++++++++++++++--------- 2 files changed, 29 insertions(+), 14 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 7b8b43dd6..4ea868bc0 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -49,7 +49,8 @@ from sklearn.base import BaseEstimator from ..utils.utils import circ_dist -__all__ = ["InvertedEncoding1D", ] +__all__ = ["InvertedEncoding1D", + "InvertedEncoding2D"] logger = logging.getLogger(__name__) MAX_CONDITION_CHECK = 9000 @@ -544,6 +545,8 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, # will create a square field of view (FOV) for the reconstruction. if not isinstance(stimulus_resolution, list): # make FOV square stimulus_resolution = [stimulus_resolution, stimulus_resolution] + if (len(stim_xlim) != 2) or (len(stim_ylim) != 2): + raise ValueError("Stimulus limits should be a sequence of 2 values") self.stim_fov = [stim_xlim, stim_ylim] self.stim_pixels = [np.linspace(stim_xlim[0], stim_xlim[1], stimulus_resolution[0]), @@ -561,15 +564,18 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, self._check_params() def _check_params(self): - if len(self.stim_fov[0]) != 2 or len(self.stim_fov[1]) != 2: + if len(self.stim_fov) != 2: + raise ValueError("Stim FOV needs to have an x-list and a y-list") + elif len(self.stim_fov[0]) != 2 or len(self.stim_fov[1]) != 2: raise ValueError("Stimulus limits should be a sequence of 2 values") else: if (self.stim_fov[0][0] >= self.stim_fov[0][1]) or \ (self.stim_fov[1][0] >= self.stim_fov[1][1]): raise ValueError("Stimulus x or y limits should be ascending values") if self.xp.size != self.yp.size: - raise ValueError("xpixel grid and ypixel grid do not have same number of elements") - if self.n_channels and self.channels: + raise ValueError("xpixel grid and ypixel grid do not have same number of " + "elements") + if self.n_channels and np.all(self.channels): if self.n_channels != self.channels.shape[0]: raise ValueError("Number of channels {} does not match the defined channels" ": {}".format(self.n_channels, self.channels.shape[0])) @@ -578,7 +584,7 @@ def _check_params(self): "represented over {} pixels. Pixels should match.".\ format(self.n_channels, self.channels.shape[1], self.xp.size)) - if self.channel_limits: + if np.all(self.channel_limits): if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ any(self.channels[:, 0] < self.channel_limits[0][0]) or \ any(self.channels[:, 1] > self.channel_limits[1][1]) or \ diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 3e7c663f4..458e289ef 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -27,12 +27,12 @@ def test_can_instantiate(): s = InvertedEncoding1D() assert s, "Invalid InvertedEncoding1D instance" - s2 = InvertedEncoding2D(stim_xlim=[0, 0], stim_ylim=[0, 0], - stimulus_resolution=[0, 0]) + s2 = InvertedEncoding2D(stim_xlim=[0, 1], stim_ylim=[0, 1], + stimulus_resolution=[1, 1]) assert s2, "Invalid InvertedEncoding2D instance" -# Simple test for checking range values. +# Test for checking range values. def test_instantiate_improper_range(): with pytest.raises(ValueError): s = InvertedEncoding1D(6, 5, 'halfcircular', range_start=20, @@ -42,10 +42,13 @@ def test_instantiate_improper_range(): s2 = InvertedEncoding2D(stim_xlim=[0, -1], stim_ylim=[0, -1], stimulus_resolution=[10, 10]) assert s2, "Invalid InvertedEncoding2D instance" + with pytest.raises(ValueError): # CATCH THIS CASE + s2 = InvertedEncoding2D(stim_xlim=[0], stim_ylim=[-1, 0], + stimulus_resolution=10) + assert s2, "Invalid InvertedEncoding2D instance" -### TESTS SPECIFIC TO 2D MODEL ### - +### TESTS FOR 2D MODEL ### # Test to check that stimulus resolution is used properly def test_2d_stimulus_resolution(): s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], @@ -92,13 +95,19 @@ def test_modify_2d_properties(): chan_ylim=bds, channels=channels) with pytest.raises(ValueError): s.set_params(n_channels=nchan - 1) + assert s, "Invalid InvertedEncoding2D instance" with pytest.raises(ValueError): - s.set_params(xp=np.random.rand(npix - 10) - # TODO: test with stim_fov? - + s.set_params(xp=np.random.rand(npix - 10)) + assert s, "Invalid InvertedEncoding2D instance" + with pytest.raises(ValueError): + s.set_params(stim_fov=[[0, 1], [0, -1]]) + assert s, "Invalid InvertedEncoding2D instance" + with pytest.raises(ValueError): + s.set_params(stim_fov=[[0, 1]]) + assert s, "Invalid InvertedEncoding2D instance" -### TESTS SPECIFIC TO 1D MODEL ### +### TESTS FOR 1D MODEL ### # Test to check stimulus resolution input def test_1d_stimulus_resolution(): s = InvertedEncoding1D(6, 5, stimulus_resolution=360) From e20e4755f27f885a8581b20c4d762689efbd77c2 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 17:52:02 -0700 Subject: [PATCH 23/39] adding circ_dist to __all__ --- brainiak/utils/utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/brainiak/utils/utils.py b/brainiak/utils/utils.py index 08402d779..cda83babd 100644 --- a/brainiak/utils/utils.py +++ b/brainiak/utils/utils.py @@ -30,6 +30,7 @@ __all__ = [ "array_correlation", "center_mass_exp", + "circ_dist", "concatenate_not_none", "cov2corr", "from_tri_2_sym", From d664e9b24cfa23f1874131449ac0af22a504d67e Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 17:53:04 -0700 Subject: [PATCH 24/39] added dummy data for 2d IEM & several accompanying tests --- tests/reconstruct/test_iem.py | 150 ++++++++++++++++++++++++++++++---- 1 file changed, 133 insertions(+), 17 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 458e289ef..7c55cfdf4 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -48,6 +48,31 @@ def test_instantiate_improper_range(): assert s2, "Invalid InvertedEncoding2D instance" +# Test for n_observations < n_channels +def test_data_amount(): + x = np.random.rand(5, 1000) + s = InvertedEncoding1D() + with pytest.raises(ValueError): + s.fit(x, np.random.rand(5)) + assert s, "Invalid data" + s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], + stimulus_resolution=10) + with pytest.raises(ValueError): + s2.fit(x, np.random.rand(5)) + + +# Test number of data dimensions +def test_data_dimensions(): + x = np.random.rand(5, 10, 2) + s = InvertedEncoding1D() + with pytest.raises(ValueError): + s.fit(x, np.random.rand(5)) + s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], + stimulus_resolution=10) + with pytest.raises(ValueError): + s2.fit(x, np.random.rand(5)) + + ### TESTS FOR 2D MODEL ### # Test to check that stimulus resolution is used properly def test_2d_stimulus_resolution(): @@ -107,6 +132,114 @@ def test_modify_2d_properties(): assert s, "Invalid InvertedEncoding2D instance" +# Define some data to use in the following tests. +nobs, nvox, ntest = 100, 1000, 5 +xlim, ylim = [[-6, 6], [-3, 3]] +sxx, syy = np.meshgrid(np.linspace(xlim[0], xlim[1], 10), + np.linspace(ylim[0], ylim[1], 10)) +yd = np.hstack((sxx.reshape(-1, 1), syy.reshape(-1, 1))) +Xd = np.zeros((nobs, nvox)) +for i, l in enumerate(np.linspace(-1, 1, 10)): + Xd[i*10:i*10+10, :] = np.random.normal(loc=l, scale=1.5, + size=(10, nvox)) +X2d = np.zeros((ntest, nvox)) +for i, l in enumerate(np.linspace(-1, 1, 5)): + X2d[i, :] = np.random.normal(loc=l, scale=1.5, + size=(1, nvox)) +iem_2d = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, + stimulus_resolution=100, stim_radius=15, + chan_xlim=xlim, chan_ylim=ylim) +iem_2d.define_basis_functions_sqgrid(nchannels=[12, 6]) + + +# Test if valid data can be fit. +def test_can_fit_2d_data(): + iem_2d.fit(Xd, yd) + + +# Show that a data matrix with improper format (dimensions) breaks the +# algorithm. +def test_cannot_fit_2d_data(): + with pytest.raises(ValueError): + iem_2d.fit(Xd.transpose(), yd) + + +def test_ill_conditioned_2d_train_data(): + with pytest.raises(ValueError): + Xt = np.random.rand(nobs, nvox) #np.array([[0, 0, 0], [1, 1, 1]]) + iem_2d.fit(Xt, np.hstack((np.random.rand(nobs), np.random.rand(nobs)))) + + +# Test case when # of observations are not matched btwn data & labels +def test_mismatched_2d_observations(): + with pytest.raises(ValueError): + iem_2d.fit(Xd, yd[:-50, :]) + + +# Test prediction capability from valid (fabricated) data +def test_can_predict_from_2d_data(): + iem_2d.fit(Xd, yd) + preds = iem_2d.predict(X2d) + assert preds.shape == (ntest, 2) + + +# Show that prediction is invalid when input data is wrong size +def test_cannot_predict_from_2d_data(): + iem_2d.fit(Xd, yd) + with pytest.raises(ValueError): + _ = iem_2d.predict(X2d.T) + + +# # Show proper scoring function with valid (fabricated) test data +# def test_can_score(): +# Invt_model = InvertedEncoding1D() +# Invt_model.fit(X, y) +# score = Invt_model.score(X2, y) +# logger.info('Scores: ' + str(score)) +# +# +# # Test scoring with invalid data formatting +# def test_cannot_score(): +# with pytest.raises(ValueError): +# Invt_model = InvertedEncoding1D() +# Invt_model.fit(X, y) +# score = Invt_model.score(X2.transpose(), y) +# logger.info('Scores: ' + str(score)) +# +# +# # Test stimulus resolution that is not even multiple +# def test_stimulus_resolution_odd(): +# Invt_model = InvertedEncoding1D(stimulus_resolution=59) +# with pytest.raises(NotImplementedError): +# Invt_model.fit(X, y) +# +# +# # Test stimulus masking +# def test_stimulus_mask(): +# Invt_model = InvertedEncoding1D(6, 5, range_start=-10, +# range_stop=170, +# stimulus_resolution=60) +# chans, _ = Invt_model._define_channels() +# Invt_model.set_params(channels_=chans) +# with pytest.warns(RuntimeWarning): +# C = Invt_model._define_trial_activations(np.array([50])) +# tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose() +# assert np.all((C - tmp_C) < 1e-7) +# +# +# # Test stimulus masking with different range +# def test_stimulus_mask_shift_positive(): +# Invt_model = InvertedEncoding1D(6, 5, range_start=10, +# range_stop=190, +# stimulus_resolution=60) +# chans, _ = Invt_model._define_channels() +# Invt_model.set_params(channels_=chans) +# with pytest.warns(RuntimeWarning): +# C = Invt_model._define_trial_activations(np.array([70])) +# tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose() +# assert np.all((C - tmp_C) < 1e-7) + + ### TESTS FOR 1D MODEL ### # Test to check stimulus resolution input def test_1d_stimulus_resolution(): @@ -142,23 +275,6 @@ def test_range_stimulus_mode_halfcirc(): assert s, "Invalid InvertedEncoding1D instance" -# Test for n_observations < n_channels -def test_data_amount(): - x = np.random.rand(5, 1000) - s = InvertedEncoding1D() - with pytest.raises(ValueError): - s.fit(x, np.random.rand(5)) - assert s, "Invalid data" - - -# Test number of data dimensions -def test_data_dimensions(): - x = np.random.rand(5, 10, 2) - s = InvertedEncoding1D() - with pytest.raises(ValueError): - s.fit(x, np.random.rand(5)) - - # Define some data to use in the following tests. n, dim = 297, 9 n_ = n // dim From 0441f89040045b2e82a783c5f418cc47766ac1ef Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 17:53:30 -0700 Subject: [PATCH 25/39] fixed PEP8 issues and docstrings --- brainiak/reconstruct/iem.py | 130 ++++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 58 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 4ea868bc0..0116f6a37 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -184,14 +184,14 @@ def _check_params(self): if (self.range_stop - self.range_start) != 180.: raise ValueError("For half-circular feature spaces," "the range must be 180 degrees, " - "not {}".format( - self.range_stop - self.range_start)) + "not {}". + format(self.range_stop - self.range_start)) elif self.stimulus_mode == 'circular': if (self.range_stop - self.range_start) != 360.: raise ValueError("For circular feature spaces, the" " range must be 360 degrees" - "not {}".format( - self.range_stop - self.range_start)) + "not {}". + format(self.range_stop - self.range_start)) if self.n_channels < 2: raise ValueError("Insufficient number of channels.") if not np.isin(self.stimulus_mode, ['circular', 'halfcircular']): @@ -512,6 +512,7 @@ class InvertedEncoding2D(BaseEstimator): Use score() to compute a measure of the error of the prediction based on known stimuli. + #TODO: fix param docstrings Parameters ---------- n_channels: int, default 5. Number of channels @@ -571,18 +572,22 @@ def _check_params(self): else: if (self.stim_fov[0][0] >= self.stim_fov[0][1]) or \ (self.stim_fov[1][0] >= self.stim_fov[1][1]): - raise ValueError("Stimulus x or y limits should be ascending values") + raise ValueError("Stimulus x or y limits should be ascending " + "values") if self.xp.size != self.yp.size: - raise ValueError("xpixel grid and ypixel grid do not have same number of " - "elements") + raise ValueError("xpixel grid and ypixel grid do not have same " + "number of elements") if self.n_channels and np.all(self.channels): if self.n_channels != self.channels.shape[0]: - raise ValueError("Number of channels {} does not match the defined channels" - ": {}".format(self.n_channels, self.channels.shape[0])) + raise ValueError("Number of channels {} does not match the " + "defined channels: {}". + format(self.n_channels, + self.channels.shape[0])) if self.channels.shape[1] != self.xp.size: - raise ValueError("Defined {} channels over {} pixels, but stimuli are " - "represented over {} pixels. Pixels should match.".\ - format(self.n_channels, self.channels.shape[1], + raise ValueError("Defined {} channels over {} pixels, but " + "stimuli are represented over {} pixels. " + "Pixels should match.". + format(self.n_channels, self.channels.shape[1], self.xp.size)) if np.all(self.channel_limits): if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ @@ -638,13 +643,13 @@ def predict(self, X): Parameters ---------- - X: numpy matrix of voxel activation from test trials - [observations, voxels]. Used to predict feature - associated with the given observation. + X: numpy matrix of voxel activation from test trials [observations, + voxels]. Used to predict feature associated with the given + observation. Returns ------- - model_prediction: numpy array of estimated feature values. + model_prediction: numpy array of estimated feature values. """ # Check that the data matrix is the right size shape_data = np.shape(X) @@ -662,14 +667,14 @@ def score(self, X, y): Parameters ---------- - X: numpy matrix of voxel activation from new data - [observations,voxels] - y: numpy array of stimulus features. [observations, 2] + X: numpy matrix of voxel activation from new data + [observations,voxels] + y: numpy array of stimulus features. [observations, 2] Returns ------- - score_value: the error measurement between the actual - feature and predicted features. + score_value: the error measurement between the actual + feature and predicted features. """ pred_features = self.predict(X) ssres = (pred_features - y) ** 2 @@ -687,8 +692,9 @@ def get_params(self): """ return {"n_channels": self.n_channels, "channel_exp": self.channel_exp, "stim_fov": self.stim_fov, "stim_pixels": self.stim_pixels, - "stim_radius_px": self.stim_radius_px, "xp": self.xp, "yp": self.yp, - "channels": self.channels, "channel_limits": self.channel_limits} + "stim_radius_px": self.stim_radius_px, "xp": self.xp, + "yp": self.yp, "channels": self.channels, "channel_limits": + self.channel_limits} def set_params(self, **parameters): """Sets model parameters after initialization. @@ -703,52 +709,53 @@ def set_params(self, **parameters): return self def _make_2d_cosine(self, x, y, x_center, y_center, s): - """Defines a 2D exponentiated cosine (isometric, e.g. constant width in x & y) - for use as a basis function. Function goes to zero at the given size constant s. - That is, the function is given by - if r <= s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp - else: 0 - where r is the Euclidean distance from the center of the function. This will + """Defines a 2D exponentiated cosine (isometric, e.g. constant width + in x & y) for use as a basis function. Function goes to zero at the + given size constant s. That is, the function is given by if r <= s: + f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp else: 0 where r is + the Euclidean distance from the center of the function. This will yield a Gaussian-like function, centered at (x_center, y_center). Parameters ---------- x: x-coordinates of the stimulus space, [npixels, 1] matrix y: y-coordinates of the stimulus space, [npixels, 1] matrix - x_center: x-coordinate of basis function centers (sequence, nchannels elements) - y_center: y-coordinate of basis function centers (sequence, nchannels elements) - r: size constant of the 2D cosine function. This is the radius where the + x_center: x-coordinate of basis function centers (sequence, nchannels) + y_center: y-coordinate of basis function centers (sequence, nchannels) + s: size constant of the 2D cosine function. This is the radius where the function is non-zero. Returns ------- - cos_functions: basis functions defined in the 2D stimulus space. returns a - [nchannels x npixels] matrix. + cos_functions: basis functions defined in the 2D stimulus space. returns + a [nchannels, npixels] matrix. """ cos_functions = np.zeros((len(x_center), len(x))) for i in range(len(x_center)): - myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2).squeeze() + myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2).\ + squeeze() qq = (myr <= s) * 1 zp = ((0.5 * (1 + np.cos(myr * np.pi / s))) ** self.channel_exp) cos_functions[i, :] = zp * qq return cos_functions def _2d_cosine_sz_to_fwhm(self, size_constant): - fwhm = 2 * size_constant \ + fwhm = 2 * size_constant \ * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi - return fwhm + return fwhm def _2d_cosine_fwhm_to_sz(self, fwhm): - """For an exponentiated 2D cosine basis function, converts the full-width - half-maximum (FWHM) of that function to the function's size constant. - The size constant is the variable s in the function below: + """For an exponentiated 2D cosine basis function, converts the + full-width half-maximum (FWHM) of that function to the function's + size constant. The size constant is the variable s in the function + below: if r <= s: f(r) = (0.5 + 0.5*cos(r*pi/s)))**channel_exp - else: 0 - where r is the Euclidean distance from the center of the function. + else: 0 where r is the Euclidean distance from the center of + the function. Parameters ---------- - fwhm: a float value indicating the full-width half-maximum in stimulus space + fwhm: a float indicating the full-width half-maximum in stimulus space Returns ------- @@ -770,10 +777,12 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): Returns ------- - self.channels: defines channels, [nchannels x npixels] matrix. + self.channels: defines channels, a [nchannels, npixels] matrix. channel_centers: numpy array of the centers of each channel # TODO: get dimensionality of channel_centers """ + # TODO: expand nchannels to list + # TODO: make sure channel limits exists chan_xcenters = np.linspace(self.channel_limits[0][0], self.channel_limits[0][1], nchannels[0]) chan_ycenters = np.linspace(self.channel_limits[1][0], @@ -790,7 +799,8 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): cos_width = self._2d_cosine_fwhm_to_sz(channel_size) # define exponentiated function self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), - self.yp.reshape(-1, 1), cx, cy, cos_width) + self.yp.reshape(-1, 1), cx, cy, + cos_width) self.n_channels = self.channels.shape[0] return self.channels, np.hstack([cx, cy]) @@ -800,7 +810,7 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): Returns ------- - self.channels: defines channels, [nchannels x npixels] matrix. + self.channels: defines channels, [nchannels, npixels] matrix. channel_centers: numpy array of the centers of each channel """ x_dist = np.diff(self.channel_limits[0]) / (grid_radius*2) @@ -828,7 +838,8 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): channel_size = 1.1*x_dist cos_width = self._2d_cosine_fwhm_to_sz(channel_size) self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), - self.yp.reshape(-1, 1), trigrid[:, 0], + self.yp.reshape(-1, 1), + trigrid[:, 0], trigrid[:, 1], cos_width) self.n_channels = self.channels.shape[0] @@ -836,15 +847,16 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): def _define_trial_activations(self, stim_centers, stim_radius=None): """Defines a numpy matrix of predicted channel responses for each - trial/observation. Assumes that the presented stimulus is circular in the 2D - stimulus space. This can include a point -- simply set stim_radius to 0.5. + trial/observation. Assumes that the presented stimulus is circular in + the 2D stimulus space. This can include a point -- simply set + stim_radius to 0.5. Parameters ------- - stim_centers: numpy array of the 2D stimulus features for each observation, + stim_centers: numpy array of 2D stimulus features for each observation, expected dimensions are [observations, 2]. - stim_radius: scalar value or array-like sequence specifying the radius of the - circular stimulus (if array-like, should have n_observations elements) + stim_radius: scalar value or array-like specifying the radius of the + circular stimulus (array-like should have n_observations elements) Returns ------- @@ -853,7 +865,7 @@ def _define_trial_activations(self, stim_centers, stim_radius=None): nstim = stim_centers.shape[0] if self.stim_radius_px is None: if stim_radius is None: - raise ValueError("No defined stimulus radius. Please set this value.") + raise ValueError("No defined stimulus radius. Please set this.") else: self.stim_radius_px = stim_radius if not isinstance(self.stim_radius_px, np.ndarray) or not isinstance( @@ -872,8 +884,8 @@ def _define_trial_activations(self, stim_centers, stim_radius=None): # Check that C is full rank if np.linalg.matrix_rank(C) < self.n_channels: warnings.warn("Stimulus matrix is {}, not full rank. May cause " - "issues with stimulus prediction/reconstruction.".format( - np.linalg.matrix_rank(C)), RuntimeWarning) + "issues with stimulus prediction/reconstruction.". + format(np.linalg.matrix_rank(C)), RuntimeWarning) return C def _predict_channel_responses(self, X): @@ -882,11 +894,12 @@ def _predict_channel_responses(self, X): Parameters ---------- - X: numpy data matrix. [observations, voxels] + X: numpy data matrix. [observations, voxels] Returns ------- - channel_response: numpy matrix of channel responses [channels, observations] + channel_response: numpy matrix of channel responses. [channels, + observations] """ channel_response = np.matmul(np.linalg.pinv(self.W_), X.transpose()) return channel_response @@ -918,7 +931,8 @@ def _predict_features(self, X): Returns ------- - pred_features: numpy matrix of predicted stimulus features. [observations, 2] + pred_features: numpy matrix of predicted stimulus features. + [observations, 2] """ pred_response = self.predict_feature_responses(X) feature_ind = np.argmax(pred_response, 0) From 63c7dde42154f7551c587fd1ae4e73c8867673fe Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Wed, 7 Oct 2020 17:57:21 -0700 Subject: [PATCH 26/39] fixing more PEP8 issues --- brainiak/reconstruct/iem.py | 39 +++++++++++++++++++------------------ 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 0116f6a37..805dcff73 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -159,8 +159,8 @@ class InvertedEncoding1D(BaseEstimator): """ def __init__(self, n_channels=6, channel_exp=5, - stimulus_mode='halfcircular', range_start=0., range_stop=180., - channel_density=180, stimulus_resolution=None): + stimulus_mode='halfcircular', range_start=0., range_stop=180., + channel_density=180, stimulus_resolution=None): self.n_channels = n_channels self.channel_exp = channel_exp self.stimulus_mode = stimulus_mode @@ -539,9 +539,10 @@ class InvertedEncoding2D(BaseEstimator): data """ - def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, - chan_xlim=[None, None], chan_ylim=[None, None], channels=None, - channel_exp=5): + def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, + stim_radius=None, + chan_xlim=[None, None], chan_ylim=[None, None], channels=None, + channel_exp=5): # Automatically expand stimulus_resolution if only one value is given. This # will create a square field of view (FOV) for the reconstruction. if not isinstance(stimulus_resolution, list): # make FOV square @@ -590,12 +591,12 @@ def _check_params(self): format(self.n_channels, self.channels.shape[1], self.xp.size)) if np.all(self.channel_limits): - if any(self.channels[:, 0] > self.channel_limits[0][1]) or \ - any(self.channels[:, 0] < self.channel_limits[0][0]) or \ - any(self.channels[:, 1] > self.channel_limits[1][1]) or \ - any(self.channels[:, 1] < self.channel_limits[1][0]): - raise ValueError("Channel limits and values defined in self.channels do not" - "match each other.") + if any(self.channels[:, 0] > self.channel_limits[0][1]) or\ + any(self.channels[:, 0] < self.channel_limits[0][0]) or\ + any(self.channels[:, 1] > self.channel_limits[1][1]) or\ + any(self.channels[:, 1] < self.channel_limits[1][0]): + raise ValueError("Channel limits and values defined in " + "self.channels do not match each other.") def fit(self, X, y): """Use data and feature variable labels to fit an IEM @@ -732,7 +733,7 @@ def _make_2d_cosine(self, x, y, x_center, y_center, s): """ cos_functions = np.zeros((len(x_center), len(x))) for i in range(len(x_center)): - myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2).\ + myr = np.sqrt((x - x_center[i]) ** 2 + (y - y_center[i]) ** 2). \ squeeze() qq = (myr <= s) * 1 zp = ((0.5 * (1 + np.cos(myr * np.pi / s))) ** self.channel_exp) @@ -741,7 +742,7 @@ def _make_2d_cosine(self, x, y, x_center, y_center, s): def _2d_cosine_sz_to_fwhm(self, size_constant): fwhm = 2 * size_constant \ - * np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5) / np.pi + * np.arccos((0.5 ** (1 / self.channel_exp) - 0.5) / 0.5) / np.pi return fwhm def _2d_cosine_fwhm_to_sz(self, fwhm): @@ -762,7 +763,7 @@ def _2d_cosine_fwhm_to_sz(self, fwhm): sz: the size constant of the exponentiated cosine """ sz = (0.5 * np.pi * fwhm) / \ - (np.arccos((0.5**(1 / self.channel_exp) - 0.5) / 0.5)) + (np.arccos((0.5 ** (1 / self.channel_exp) - 0.5) / 0.5)) return sz def define_basis_functions_sqgrid(self, nchannels, channel_size=None): @@ -795,7 +796,7 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): # spacing between the channels might work. (See Sprague et al. 2013 # Methods & Supplementary Figure 3 -- this is for cosine exponent 7, # your mileage may vary for other exponents!). - channel_size = 1.2*(chan_xcenters[1] - chan_xcenters[0]) + channel_size = 1.2 * (chan_xcenters[1] - chan_xcenters[0]) cos_width = self._2d_cosine_fwhm_to_sz(channel_size) # define exponentiated function self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), @@ -813,7 +814,7 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): self.channels: defines channels, [nchannels, npixels] matrix. channel_centers: numpy array of the centers of each channel """ - x_dist = np.diff(self.channel_limits[0]) / (grid_radius*2) + x_dist = np.diff(self.channel_limits[0]) / (grid_radius * 2) y_dist = x_dist * np.sqrt(3) * 0.5 trigrid = np.zeros((0, 2)) xbase = np.expand_dims(np.arange(self.channel_limits[0][0], @@ -835,7 +836,7 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): # spacing between the channels might work. (See Sprague et al. 2013 # Methods & Supplementary Figure 3 -- this is for cosine exponent 7, # your mileage may vary for other exponents!). - channel_size = 1.1*x_dist + channel_size = 1.1 * x_dist cos_width = self._2d_cosine_fwhm_to_sz(channel_size) self.channels = self._make_2d_cosine(self.xp.reshape(-1, 1), self.yp.reshape(-1, 1), @@ -874,8 +875,8 @@ def _define_trial_activations(self, stim_centers, stim_radius=None): # Create a mask for every stimulus observation in the stimulus domain stimulus_mask = np.zeros((self.xp.size, nstim)) for i in range(nstim): - rad_vals = ((self.xp.reshape(-1, 1) - stim_centers[i, 0])**2 + - (self.yp.reshape(-1, 1) - stim_centers[i, 1])**2) + rad_vals = ((self.xp.reshape(-1, 1) - stim_centers[i, 0]) ** 2 + + (self.yp.reshape(-1, 1) - stim_centers[i, 1]) ** 2) inds = np.where(rad_vals < self.stim_radius_px[i])[0] stimulus_mask[inds, i] = 1 # Go from the stimulus domain to the channel domain From d3e2d8763ee9a9341629c79ae3cff213fd2a171d Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Fri, 9 Oct 2020 14:43:01 -0700 Subject: [PATCH 27/39] fixed docstrings throughout, including class docstring. Changed default stimulus x- & y-limits to be the same as the stimulus x- & y-limits --- brainiak/reconstruct/iem.py | 104 ++++++++++++++++++++++++------------ 1 file changed, 70 insertions(+), 34 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 805dcff73..9cb4bf3a4 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -465,8 +465,10 @@ class InvertedEncoding2D(BaseEstimator): user). The documentation will refer to the 'stimulus space' or 'stimulus domain', - which should be a 2D space in consistent units (e.g. pixels, or degrees - visual angle). + which should be a 2D space in consistent units (e.g. screen pixels, + or degrees visual angle). The stimulus space is the domain in which the + stimulus is reconstructed. We will refer to the each point in this 2D + stimulus domain as a 'pixel'. The model: Inverted encoding models reconstruct a stimulus feature from @@ -512,37 +514,54 @@ class InvertedEncoding2D(BaseEstimator): Use score() to compute a measure of the error of the prediction based on known stimuli. - #TODO: fix param docstrings Parameters ---------- - n_channels: int, default 5. Number of channels - The number of channels, or basis functions, to be used in - the inverted encoding model. + stim_xlim: list of 2 floats Specifies the minimum and maximum x-values + of the area to be reconstructed. In order to be estimated properly, a + stimulus must appear at these limits. Specifying limits outside the + range of the stimuli can lead to spurious estimates. - channel_exp: int, default 6. Basis function exponent. - The exponent of the sinuoidal basis functions, which - establishes the width of the functions. + stim_ylim: list of 2 floats Specifies the minimum and maximum y-values + of the area to be reconstructed. In order to be estimated properly, a + stimulus must appear at these limits. Specifying limits outside the + range of the stimuli can lead to spurious estimates. - stimulus_resolution: double, default None will set the stimulus - resolution to be identical to the channel density. This sets - the resolution at which the stimuli were presented (e.g. a - spatial position with some width has a lower stimulus - resolution). + stimulus_resolution: float or list of 2 floats. If a single float is + given, it will be expanded to a list (i.e. we will assume that the + reconstructed area is composed of square pixels). + + stim_radius: float, or sequence of floats [n_stim], default None. If the + user does not define the design matrix of the encoding model (e.g. C + in B = W*C), it will be defined automatically on the assumption that + each observation was for a 2D circular stimulus of some radius. + + chan_xlim: list of 2 floats, default None. Specifies the minimum and + maximum x-values of the channels, or basis functions. + + chan_ylim: list of 2 floats, default None. Specifies the minimum and + maximum y-values of the channels, or basis functions. + + channels: [n_channels, n_pixels] NumPy 2D array, default None. If None at + initialization, it can be defined with + either define_basis_functions_sqgrid() or + define_basis_functions_trigrid(), each of which tiles the given 2D + space with some grid (square or triangular/hexagonal, respectively). + Alternatively, the user can specify their own channels. + + channel_exp: int, default 7. Basis function exponent. The exponent of the + sinuoidal basis functions, which establishes the width of the functions. Attributes ---------- - channels_: [n_channels, channel density] NumPy 2D array - matrix defining channel values + channels: [n_channels, n_pixels] NumPy 2D array defining channels - W_: sklearn.linear_model model containing weight matrix that - relates estimated channel responses to response amplitude - data + W_: sklearn.linear_model containing weight matrix that relates estimated + channel responses to response data """ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, - stim_radius=None, - chan_xlim=[None, None], chan_ylim=[None, None], channels=None, - channel_exp=5): + stim_radius=None, chan_xlim=None, chan_ylim=None, channels=None, + channel_exp=7): # Automatically expand stimulus_resolution if only one value is given. This # will create a square field of view (FOV) for the reconstruction. if not isinstance(stimulus_resolution, list): # make FOV square @@ -554,13 +573,19 @@ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stimulus_resolution[0]), np.linspace(stim_ylim[0], stim_ylim[1], stimulus_resolution[1])] - self.stim_radius_px = stim_radius self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) + self.stim_radius_px = stim_radius self.channels = channels if self.channels is None: self.n_channels = None else: self.n_channels = self.channels.shape[0] + if chan_xlim is None: + chan_xlim = stim_xlim + logger.info("Set channel x-limits to stimulus x-limits", stim_xlim) + if chan_ylim is None: + chan_ylim = stim_ylim + logger.info("Set channel y-limits to stimulus y-limits", stim_ylim) self.channel_limits = [chan_xlim, chan_ylim] self.channel_exp = channel_exp self._check_params() @@ -598,7 +623,7 @@ def _check_params(self): raise ValueError("Channel limits and values defined in " "self.channels do not match each other.") - def fit(self, X, y): + def fit(self, X, y, C=None): """Use data and feature variable labels to fit an IEM Parameters @@ -608,6 +633,11 @@ def fit(self, X, y): trial and each voxel of training data. y: numpy array of response variable. [observations] Should contain the feature for each observation in X. + C: numpy matrix of channel activations for every observation (e.g. + the design matrix C in the linear equation B = W*C). Size of matrix: + [observations, pixels]. If None (default), this assumes that each + observation contains a 2D circular stimulus and will define the + activations with self._define_trial_activations(y). """ # Check that data matrix is well conditioned: if np.linalg.cond(X) > MAX_CONDITION_CHECK: @@ -628,9 +658,10 @@ def fit(self, X, y): else: if shape_data[0] != shape_labels[0]: raise ValueError("Mismatched data samples and label samples") - # Create a matrix of channel activations for every observation. - # (i.e., C1 in Brouwer & Heeger 2009.) - C = self._define_trial_activations(y) + if C is None: + # Create a matrix of channel activations for every observation. + # (i.e., C1 in Brouwer & Heeger 2009.) + C = self._define_trial_activations(y) # Solve for W in B = WC self.W_ = X.transpose() @ np.linalg.pinv(C.transpose()) if np.linalg.cond(self.W_) > MAX_CONDITION_CHECK: @@ -677,6 +708,7 @@ def score(self, X, y): score_value: the error measurement between the actual feature and predicted features. """ + # TODO: add other scoring methods pred_features = self.predict(X) ssres = (pred_features - y) ** 2 sstot = (y - np.mean(y)) ** 2 @@ -779,11 +811,12 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): Returns ------- self.channels: defines channels, a [nchannels, npixels] matrix. - channel_centers: numpy array of the centers of each channel - # TODO: get dimensionality of channel_centers + channel_centers: numpy array of the centers of each channel, given as + [nchannels x 2] matrix """ - # TODO: expand nchannels to list - # TODO: make sure channel limits exists + # If given a single value for nchannels, expand to make a square + if not isinstance(nchannels, list): + nchannels = [nchannels, nchannels] chan_xcenters = np.linspace(self.channel_limits[0][0], self.channel_limits[0][1], nchannels[0]) chan_ycenters = np.linspace(self.channel_limits[1][0], @@ -849,15 +882,18 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): def _define_trial_activations(self, stim_centers, stim_radius=None): """Defines a numpy matrix of predicted channel responses for each trial/observation. Assumes that the presented stimulus is circular in - the 2D stimulus space. This can include a point -- simply set - stim_radius to 0.5. + the 2D stimulus space. This can effectively be a single circular + pixel if stim_radius=0.5. Parameters ------- stim_centers: numpy array of 2D stimulus features for each observation, expected dimensions are [observations, 2]. stim_radius: scalar value or array-like specifying the radius of the - circular stimulus (array-like should have n_observations elements) + circular stimulus for each observation, [observations]. While + this can be read-out from the property self.stim_radius_px, + here the user can specify it in case they are retraining the + model with new observations. Returns ------- From a9c9f2b8f511031f853f7db4d036d852a8f06b92 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Fri, 9 Oct 2020 16:14:06 -0700 Subject: [PATCH 28/39] fixed scoring function and added another scoring option --- brainiak/reconstruct/iem.py | 43 ++++++++++++++++++++++++++++------- tests/reconstruct/test_iem.py | 40 +++++++++++++------------------- 2 files changed, 51 insertions(+), 32 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 9cb4bf3a4..b77f53e3d 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -47,6 +47,7 @@ import numpy as np import scipy.stats from sklearn.base import BaseEstimator +from sklearn.metrics.pairwise import cosine_distances, euclidean_distances from ..utils.utils import circ_dist __all__ = ["InvertedEncoding1D", @@ -361,7 +362,7 @@ def _define_trial_activations(self, stimuli): Parameters stimuli: numpy array of the feature values for each - observation (e.g., [0, 5, 15, 30, ...] degrees) + observation Returns ------- @@ -694,8 +695,8 @@ def predict(self, X): return model_prediction def score(self, X, y): - """Calculate error measure of prediction. Default measurement - is R^2, the coefficient of determination. + """Calculate error measure of prediction, assuming that the predicted + feature is at the maximum of the reconstructed values. Parameters ---------- @@ -706,16 +707,42 @@ def score(self, X, y): Returns ------- score_value: the error measurement between the actual - feature and predicted features. + feature and predicted features, [observations]. """ - # TODO: add other scoring methods pred_features = self.predict(X) - ssres = (pred_features - y) ** 2 - sstot = (y - np.mean(y)) ** 2 - score_value = (1 - ssres / sstot) + ssres = np.sum((pred_features - y) ** 2, axis=1) + sstot = np.sum((y - np.mean(y)) ** 2, axis=1) + score_value = 1 - (ssres / sstot) return score_value + def score_against_reconstructed(self, X, y, metric="euclidean"): + """Calculates a distance metric between reconstructed features in + the 2D stimulus domain (i.e. reconstructions in pixels) given + some observations X, and expected features y. Expected features must + also be in the pixel stimulus domain. + + Parameters + ---------- + X: numpy matrix of voxel activation from new data + [observations, voxels] + y: numpy array of the expected stimulus reconstruction values [pixels, + observations]. + metric: string specifying the distance metric, either "euclidean" or + "cosine". + + Returns + ------- + score_value: the error measurement between the reconstructed feature + values as the expected values, [observations]. + """ + yhat = self.predict_feature_responses(X) + if metric == "euclidean": + score_value = euclidean_distances(y.T, yhat.T) + elif metric == "cosine": + score_value = cosine_distances(y.T, yhat.T) + return score_value[0, :] + def get_params(self): """Returns model parameters. diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 7c55cfdf4..7a06bd452 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -132,6 +132,9 @@ def test_modify_2d_properties(): assert s, "Invalid InvertedEncoding2D instance" +# TODO: test attempt to fit with C=None and stim_radius=None + + # Define some data to use in the following tests. nobs, nvox, ntest = 100, 1000, 5 xlim, ylim = [[-6, 6], [-3, 3]] @@ -190,30 +193,19 @@ def test_cannot_predict_from_2d_data(): _ = iem_2d.predict(X2d.T) -# # Show proper scoring function with valid (fabricated) test data -# def test_can_score(): -# Invt_model = InvertedEncoding1D() -# Invt_model.fit(X, y) -# score = Invt_model.score(X2, y) -# logger.info('Scores: ' + str(score)) -# -# -# # Test scoring with invalid data formatting -# def test_cannot_score(): -# with pytest.raises(ValueError): -# Invt_model = InvertedEncoding1D() -# Invt_model.fit(X, y) -# score = Invt_model.score(X2.transpose(), y) -# logger.info('Scores: ' + str(score)) -# -# -# # Test stimulus resolution that is not even multiple -# def test_stimulus_resolution_odd(): -# Invt_model = InvertedEncoding1D(stimulus_resolution=59) -# with pytest.raises(NotImplementedError): -# Invt_model.fit(X, y) -# -# +# Show proper scoring function with valid (fabricated) test data +def test_can_score_2d(): + iem_2d.fit(Xd, yd) + score = iem_2d.score(X2d, yd[ntest, :]) + + +# Test scoring with invalid data formatting +def test_cannot_score_2d(): + with pytest.raises(ValueError): + iem_2d.fit(Xd, yd) + score = iem_2d.score(X2d.transpose(), yd[ntest, :]) + + # # Test stimulus masking # def test_stimulus_mask(): # Invt_model = InvertedEncoding1D(6, 5, range_start=-10, From e67df0ab425619464597dc54d2b15acb1f867f98 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Fri, 9 Oct 2020 16:14:45 -0700 Subject: [PATCH 29/39] added tests to cover defined or undefined stimulus radius and design matrix C --- tests/reconstruct/test_iem.py | 67 +++++++++++++++++++++++++---------- 1 file changed, 48 insertions(+), 19 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 7a06bd452..214dc94db 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -132,12 +132,10 @@ def test_modify_2d_properties(): assert s, "Invalid InvertedEncoding2D instance" -# TODO: test attempt to fit with C=None and stim_radius=None - - # Define some data to use in the following tests. nobs, nvox, ntest = 100, 1000, 5 xlim, ylim = [[-6, 6], [-3, 3]] +res = [100, 100] sxx, syy = np.meshgrid(np.linspace(xlim[0], xlim[1], 10), np.linspace(ylim[0], ylim[1], 10)) yd = np.hstack((sxx.reshape(-1, 1), syy.reshape(-1, 1))) @@ -149,9 +147,43 @@ def test_modify_2d_properties(): for i, l in enumerate(np.linspace(-1, 1, 5)): X2d[i, :] = np.random.normal(loc=l, scale=1.5, size=(1, nvox)) + + +# Test that 2D model raises error if design matrix C cannot be defined +def test_fit_invalid_2d(): + # C=None and stim_radius=None here, cannot define C + i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, + stimulus_resolution=res, stim_radius=None) + i2.define_basis_functions_sqgrid(nchannels=[12, 6]) + with pytest.raises(ValueError): + i2.fit(Xd, yd) + + +# Test attempt to fit with list of varying stimulus radii +def test_fit_2d_radius_list(): + i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, + stimulus_resolution=res, + stim_radius=np.random.rand(nobs)) + i2.define_basis_functions_sqgrid(nchannels=[12, 6]) + i2.fit(Xd, yd) + + +# Test with custom C input +def test_fit_2d_radius_list(): + i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, + stimulus_resolution=res, + stim_radius=12) + i2.define_basis_functions_sqgrid(nchannels=[12, 6]) + # Define C by expanding y & adding noise to avoid singular W matrix error + C0 = np.repeat(np.expand_dims(yd[:, 0], 1), 12*3, axis=1) + \ + np.random.rand(nobs, 12*3) + C1 = np.repeat(np.expand_dims(yd[:, 1], 1), 12*3, axis=1) + \ + np.random.rand(nobs, 12*3) + i2.fit(Xd, yd, np.hstack((C0, C1))) + + iem_2d = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, - stimulus_resolution=100, stim_radius=15, - chan_xlim=xlim, chan_ylim=ylim) + stimulus_resolution=res, stim_radius=12) iem_2d.define_basis_functions_sqgrid(nchannels=[12, 6]) @@ -196,7 +228,17 @@ def test_cannot_predict_from_2d_data(): # Show proper scoring function with valid (fabricated) test data def test_can_score_2d(): iem_2d.fit(Xd, yd) - score = iem_2d.score(X2d, yd[ntest, :]) + score = iem_2d.score(X2d, yd[:ntest, :]) + assert score.shape == (ntest,) + score = iem_2d.score_against_reconstructed(X2d, + np.random.rand(res[0]*res[1], + ntest)) + assert score.shape == (ntest,) + score = iem_2d.score_against_reconstructed(X2d, + np.random.rand(res[0]*res[1], + ntest), + metric="cosine") + assert score.shape == (ntest,) # Test scoring with invalid data formatting @@ -217,19 +259,6 @@ def test_cannot_score_2d(): # C = Invt_model._define_trial_activations(np.array([50])) # tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose() # assert np.all((C - tmp_C) < 1e-7) -# -# -# # Test stimulus masking with different range -# def test_stimulus_mask_shift_positive(): -# Invt_model = InvertedEncoding1D(6, 5, range_start=10, -# range_stop=190, -# stimulus_resolution=60) -# chans, _ = Invt_model._define_channels() -# Invt_model.set_params(channels_=chans) -# with pytest.warns(RuntimeWarning): -# C = Invt_model._define_trial_activations(np.array([70])) -# tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose() -# assert np.all((C - tmp_C) < 1e-7) ### TESTS FOR 1D MODEL ### From 4a3de32793fdba4c683eeee007f0c7ac9d312094 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Fri, 9 Oct 2020 16:26:47 -0700 Subject: [PATCH 30/39] PEP8 formatting --- brainiak/reconstruct/iem.py | 59 +++++++++++++++++++---------------- tests/reconstruct/test_iem.py | 21 +++++++------ 2 files changed, 43 insertions(+), 37 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index b77f53e3d..51d5b4339 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -160,8 +160,8 @@ class InvertedEncoding1D(BaseEstimator): """ def __init__(self, n_channels=6, channel_exp=5, - stimulus_mode='halfcircular', range_start=0., range_stop=180., - channel_density=180, stimulus_resolution=None): + stimulus_mode='halfcircular', range_start=0., range_stop=180., + channel_density=180, stimulus_resolution=None): self.n_channels = n_channels self.channel_exp = channel_exp self.stimulus_mode = stimulus_mode @@ -288,7 +288,8 @@ def score(self, X, y): pred_features = pred_features * 2 y = y * 2 - ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features)) ** 2).sum() + ssres = (circ_dist(np.deg2rad(y), + np.deg2rad(pred_features)) ** 2).sum() sstot = (circ_dist(np.deg2rad(y), np.ones(y.size) * scipy.stats.circmean( np.deg2rad(y))) ** 2).sum() @@ -394,8 +395,8 @@ def _define_trial_activations(self, stimuli): # Check that C is full rank if np.linalg.matrix_rank(C) < self.n_channels: warnings.warn("Stimulus matrix is {}, not full rank. May cause " - "issues with stimulus prediction/reconstruction.".format( - np.linalg.matrix_rank(C)), RuntimeWarning) + "issues with stimulus prediction/reconstruction.". + format(np.linalg.matrix_rank(C)), RuntimeWarning) return C def _predict_channel_responses(self, X): @@ -462,8 +463,8 @@ class InvertedEncoding2D(BaseEstimator): stimulus feature (e.g. 2D spatial position) to basis function is one- to-one and invertible. The response of a voxel is expressed as the weighted sum of basis functions. In this implementation, basis functions - were half-wave rectified sinusoid functions raised to some power (set by the - user). + were half-wave rectified sinusoid functions raised to some power (set by + the user). The documentation will refer to the 'stimulus space' or 'stimulus domain', which should be a 2D space in consistent units (e.g. screen pixels, @@ -550,7 +551,7 @@ class InvertedEncoding2D(BaseEstimator): Alternatively, the user can specify their own channels. channel_exp: int, default 7. Basis function exponent. The exponent of the - sinuoidal basis functions, which establishes the width of the functions. + sinuoidal basis functions, which helps control their width. Attributes ---------- @@ -561,20 +562,22 @@ class InvertedEncoding2D(BaseEstimator): """ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, - stim_radius=None, chan_xlim=None, chan_ylim=None, channels=None, - channel_exp=7): - # Automatically expand stimulus_resolution if only one value is given. This - # will create a square field of view (FOV) for the reconstruction. + stim_radius=None, chan_xlim=None, chan_ylim=None, + channels=None, channel_exp=7): + # Automatically expand stimulus_resolution if only one value is given. + # This will create a square field of view (FOV) for the + # reconstruction. if not isinstance(stimulus_resolution, list): # make FOV square stimulus_resolution = [stimulus_resolution, stimulus_resolution] if (len(stim_xlim) != 2) or (len(stim_ylim) != 2): - raise ValueError("Stimulus limits should be a sequence of 2 values") + raise ValueError("Stimulus limits should be a sequence, 2 values") self.stim_fov = [stim_xlim, stim_ylim] self.stim_pixels = [np.linspace(stim_xlim[0], stim_xlim[1], stimulus_resolution[0]), np.linspace(stim_ylim[0], stim_ylim[1], stimulus_resolution[1])] - self.xp, self.yp = np.meshgrid(self.stim_pixels[0], self.stim_pixels[1]) + self.xp, self.yp = np.meshgrid(self.stim_pixels[0], + self.stim_pixels[1]) self.stim_radius_px = stim_radius self.channels = channels if self.channels is None: @@ -595,7 +598,7 @@ def _check_params(self): if len(self.stim_fov) != 2: raise ValueError("Stim FOV needs to have an x-list and a y-list") elif len(self.stim_fov[0]) != 2 or len(self.stim_fov[1]) != 2: - raise ValueError("Stimulus limits should be a sequence of 2 values") + raise ValueError("Stimulus limits should be a sequence, 2 values") else: if (self.stim_fov[0][0] >= self.stim_fov[0][1]) or \ (self.stim_fov[1][0] >= self.stim_fov[1][1]): @@ -614,12 +617,13 @@ def _check_params(self): raise ValueError("Defined {} channels over {} pixels, but " "stimuli are represented over {} pixels. " "Pixels should match.". - format(self.n_channels, self.channels.shape[1], + format(self.n_channels, + self.channels.shape[1], self.xp.size)) if np.all(self.channel_limits): if any(self.channels[:, 0] > self.channel_limits[0][1]) or\ - any(self.channels[:, 0] < self.channel_limits[0][0]) or\ - any(self.channels[:, 1] > self.channel_limits[1][1]) or\ + any(self.channels[:, 0] < self.channel_limits[0][0]) or\ + any(self.channels[:, 1] > self.channel_limits[1][1]) or\ any(self.channels[:, 1] < self.channel_limits[1][0]): raise ValueError("Channel limits and values defined in " "self.channels do not match each other.") @@ -635,7 +639,7 @@ def fit(self, X, y, C=None): y: numpy array of response variable. [observations] Should contain the feature for each observation in X. C: numpy matrix of channel activations for every observation (e.g. - the design matrix C in the linear equation B = W*C). Size of matrix: + the design matrix C in the linear equation B = W*C), matrix size [observations, pixels]. If None (default), this assumes that each observation contains a 2D circular stimulus and will define the activations with self._define_trial_activations(y). @@ -782,13 +786,13 @@ def _make_2d_cosine(self, x, y, x_center, y_center, s): y: y-coordinates of the stimulus space, [npixels, 1] matrix x_center: x-coordinate of basis function centers (sequence, nchannels) y_center: y-coordinate of basis function centers (sequence, nchannels) - s: size constant of the 2D cosine function. This is the radius where the - function is non-zero. + s: size constant of the 2D cosine function. This is the radius where + the function is non-zero. Returns ------- - cos_functions: basis functions defined in the 2D stimulus space. returns - a [nchannels, npixels] matrix. + cos_functions: basis functions defined in the 2D stimulus space. + returns a [nchannels, npixels] matrix. """ cos_functions = np.zeros((len(x_center), len(x))) for i in range(len(x_center)): @@ -854,7 +858,7 @@ def define_basis_functions_sqgrid(self, nchannels, channel_size=None): if channel_size is None: # To get even coverage, setting the channel FWHM to ~1.1x-1.2x the # spacing between the channels might work. (See Sprague et al. 2013 - # Methods & Supplementary Figure 3 -- this is for cosine exponent 7, + # Methods & Supplementary Figure 3 -- this is for cosine exp = 7, # your mileage may vary for other exponents!). channel_size = 1.2 * (chan_xcenters[1] - chan_xcenters[0]) cos_width = self._2d_cosine_fwhm_to_sz(channel_size) @@ -894,7 +898,7 @@ def define_basis_functions_trigrid(self, grid_radius, channel_size=None): if channel_size is None: # To get even coverage, setting the channel FWHM to ~1.1x-1.2x the # spacing between the channels might work. (See Sprague et al. 2013 - # Methods & Supplementary Figure 3 -- this is for cosine exponent 7, + # Methods & Supplementary Figure 3 -- this is for cosine exp = 7, # your mileage may vary for other exponents!). channel_size = 1.1 * x_dist cos_width = self._2d_cosine_fwhm_to_sz(channel_size) @@ -929,7 +933,7 @@ def _define_trial_activations(self, stim_centers, stim_radius=None): nstim = stim_centers.shape[0] if self.stim_radius_px is None: if stim_radius is None: - raise ValueError("No defined stimulus radius. Please set this.") + raise ValueError("No defined stimulus radius. Please set.") else: self.stim_radius_px = stim_radius if not isinstance(self.stim_radius_px, np.ndarray) or not isinstance( @@ -987,7 +991,8 @@ def predict_feature_responses(self, X): def _predict_features(self, X): """Predicts feature value from data in X. - Takes the maximum of the 'reconstructed' or predicted response function. + Takes the maximum of the reconstructed, i.e. predicted response + function. Parameters --------- diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 214dc94db..b6d15d41d 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -42,7 +42,7 @@ def test_instantiate_improper_range(): s2 = InvertedEncoding2D(stim_xlim=[0, -1], stim_ylim=[0, -1], stimulus_resolution=[10, 10]) assert s2, "Invalid InvertedEncoding2D instance" - with pytest.raises(ValueError): # CATCH THIS CASE + with pytest.raises(ValueError): s2 = InvertedEncoding2D(stim_xlim=[0], stim_ylim=[-1, 0], stimulus_resolution=10) assert s2, "Invalid InvertedEncoding2D instance" @@ -73,15 +73,15 @@ def test_data_dimensions(): s2.fit(x, np.random.rand(5)) -### TESTS FOR 2D MODEL ### +# TESTS FOR 2D MODEL # # Test to check that stimulus resolution is used properly def test_2d_stimulus_resolution(): s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], - stimulus_resolution=10) + stimulus_resolution=10) assert len(s2.stim_pixels[0] == 10) assert len(s2.stim_pixels[1] == 10) s2 = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-2, 2], - stimulus_resolution=[10, 20]) + stimulus_resolution=[10, 20]) assert len(s2.stim_pixels[0] == 10) assert len(s2.stim_pixels[1] == 20) @@ -142,11 +142,11 @@ def test_modify_2d_properties(): Xd = np.zeros((nobs, nvox)) for i, l in enumerate(np.linspace(-1, 1, 10)): Xd[i*10:i*10+10, :] = np.random.normal(loc=l, scale=1.5, - size=(10, nvox)) + size=(10, nvox)) X2d = np.zeros((ntest, nvox)) for i, l in enumerate(np.linspace(-1, 1, 5)): X2d[i, :] = np.random.normal(loc=l, scale=1.5, - size=(1, nvox)) + size=(1, nvox)) # Test that 2D model raises error if design matrix C cannot be defined @@ -169,7 +169,7 @@ def test_fit_2d_radius_list(): # Test with custom C input -def test_fit_2d_radius_list(): +def test_fit_custom_C(): i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, stimulus_resolution=res, stim_radius=12) @@ -201,7 +201,7 @@ def test_cannot_fit_2d_data(): def test_ill_conditioned_2d_train_data(): with pytest.raises(ValueError): - Xt = np.random.rand(nobs, nvox) #np.array([[0, 0, 0], [1, 1, 1]]) + Xt = np.random.rand(nobs, nvox) iem_2d.fit(Xt, np.hstack((np.random.rand(nobs), np.random.rand(nobs)))) @@ -243,9 +243,10 @@ def test_can_score_2d(): # Test scoring with invalid data formatting def test_cannot_score_2d(): + iem_2d.fit(Xd, yd) with pytest.raises(ValueError): - iem_2d.fit(Xd, yd) score = iem_2d.score(X2d.transpose(), yd[ntest, :]) + assert score # # Test stimulus masking @@ -261,7 +262,7 @@ def test_cannot_score_2d(): # assert np.all((C - tmp_C) < 1e-7) -### TESTS FOR 1D MODEL ### +# TESTS FOR 1D MODEL # # Test to check stimulus resolution input def test_1d_stimulus_resolution(): s = InvertedEncoding1D(6, 5, stimulus_resolution=360) From 2bf83c5588a0bce6b0dc68aa9aabd8aba9b78423 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Fri, 9 Oct 2020 17:47:52 -0700 Subject: [PATCH 31/39] added tests for helper functions + functions to define grid of channels --- tests/reconstruct/test_iem.py | 83 +++++++++++++++++++++++++++++------ 1 file changed, 69 insertions(+), 14 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index b6d15d41d..a84cf40b4 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -132,6 +132,73 @@ def test_modify_2d_properties(): assert s, "Invalid InvertedEncoding2D instance" +# Test helper function to create 2D cosine +def test_2d_cos(): + nchan = 8 + res = 10 + npix = res*res + bds = [-1, 1] + sz = 2 + s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=res, + channels=np.random.rand(nchan, npix)) + sz = s._2d_cosine_fwhm_to_sz(1) + fcn = s._make_2d_cosine(s.xp.reshape(-1, 1), s.yp.reshape(-1, 1), + np.linspace(bds[0], bds[1], nchan), + np.linspace(bds[0], bds[1], nchan), sz) + assert fcn.shape == (nchan, npix) + # Test that masking works -- basis function should have fewer non-zero + # elements than specified by the size constant + xd = np.diff(s.xp)[0][0] + nval = (np.nonzero(fcn[0, :])[0]).size + assert nval*(xd**2) <= sz**2 + + +# Test size conversion functions +def test_2d_cos_size_fcns(): + bds = [-1, 1] + s = np.random.rand() + imodel = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=10) + fwhm = imodel._2d_cosine_sz_to_fwhm(s) + s2 = imodel._2d_cosine_fwhm_to_sz(fwhm) + assert s == s2 + fwhm2 = imodel._2d_cosine_sz_to_fwhm(s2) + assert fwhm == fwhm2 + + +def test_square_basis_grid(): + nchan = 8 + bds = [-1, 1] + s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=10) + _, centers = s.define_basis_functions_sqgrid(nchannels=nchan) + assert centers.shape[0] == nchan*nchan + xspacing = np.round(np.diff(centers[:, 0]), 5) + yspacing = np.round(np.diff(centers[:, 1]), 5) + assert xspacing[0] == xspacing[np.random.randint(nchan*nchan)] == \ + xspacing[-1] + assert yspacing[0] == yspacing[np.random.randint(nchan * nchan)] == \ + yspacing[-1] + + +def test_triangular_basis_grid(): + grid_rad = 3 + n_channels = (grid_rad*2 + 1) * (grid_rad*2) + bds = [-1, 1] + s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=10) + _, centers = s.define_basis_functions_trigrid(grid_rad) + assert centers.shape[0] == n_channels + xspacing = np.round(np.diff(centers[:, 0]), 4) + assert xspacing[0] == xspacing[np.random.randint(n_channels)] == \ + xspacing[-1] + ysp = xspacing[0] * np.sqrt(3) * 0.5 + yspacing = np.diff(centers[:, 1]) + yspace = yspacing[yspacing > 0.0] + assert np.all((ysp - yspace) < 1e-5) + + # Define some data to use in the following tests. nobs, nvox, ntest = 100, 1000, 5 xlim, ylim = [[-6, 6], [-3, 3]] @@ -169,7 +236,7 @@ def test_fit_2d_radius_list(): # Test with custom C input -def test_fit_custom_C(): +def test_fit_custom_channel_activations(): i2 = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, stimulus_resolution=res, stim_radius=12) @@ -180,6 +247,7 @@ def test_fit_custom_C(): C1 = np.repeat(np.expand_dims(yd[:, 1], 1), 12*3, axis=1) + \ np.random.rand(nobs, 12*3) i2.fit(Xd, yd, np.hstack((C0, C1))) + assert np.all(i2.W_) iem_2d = InvertedEncoding2D(stim_xlim=xlim, stim_ylim=ylim, @@ -249,19 +317,6 @@ def test_cannot_score_2d(): assert score -# # Test stimulus masking -# def test_stimulus_mask(): -# Invt_model = InvertedEncoding1D(6, 5, range_start=-10, -# range_stop=170, -# stimulus_resolution=60) -# chans, _ = Invt_model._define_channels() -# Invt_model.set_params(channels_=chans) -# with pytest.warns(RuntimeWarning): -# C = Invt_model._define_trial_activations(np.array([50])) -# tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose() -# assert np.all((C - tmp_C) < 1e-7) - - # TESTS FOR 1D MODEL # # Test to check stimulus resolution input def test_1d_stimulus_resolution(): From 8c24a2aea0edcfc25f3f89d985c903c3264a2348 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Sat, 10 Oct 2020 11:20:42 -0700 Subject: [PATCH 32/39] removing unnecessary tests --- brainiak/reconstruct/iem.py | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 51d5b4339..8e81d90fb 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -620,13 +620,6 @@ def _check_params(self): format(self.n_channels, self.channels.shape[1], self.xp.size)) - if np.all(self.channel_limits): - if any(self.channels[:, 0] > self.channel_limits[0][1]) or\ - any(self.channels[:, 0] < self.channel_limits[0][0]) or\ - any(self.channels[:, 1] > self.channel_limits[1][1]) or\ - any(self.channels[:, 1] < self.channel_limits[1][0]): - raise ValueError("Channel limits and values defined in " - "self.channels do not match each other.") def fit(self, X, y, C=None): """Use data and feature variable labels to fit an IEM @@ -658,11 +651,8 @@ def fit(self, X, y, C=None): # Check that the data matrix is the right size shape_data = np.shape(X) shape_labels = np.shape(y) - if len(shape_data) != 2: - raise ValueError("Data matrix has too many or too few dimensions.") - else: - if shape_data[0] != shape_labels[0]: - raise ValueError("Mismatched data samples and label samples") + if shape_data[0] != shape_labels[0]: + raise ValueError("Mismatched data samples and label samples") if C is None: # Create a matrix of channel activations for every observation. # (i.e., C1 in Brouwer & Heeger 2009.) From 5d0704bdff9beee855ce2ea3abd81080fd111b3a Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Sat, 10 Oct 2020 11:21:34 -0700 Subject: [PATCH 33/39] added tests for singular or low rank matrices across all steps of the model. added get param tests. added other statements to increase test coverage --- tests/reconstruct/test_iem.py | 52 +++++++++++++++++++++++++++++++---- 1 file changed, 47 insertions(+), 5 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index a84cf40b4..9915f8223 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -101,6 +101,7 @@ def test_2d_custom_channels(): # Test that channel definition should be consistent. def test_cannot_instantiate_2d_channels(): + # Channel definition over wrong number of pixels (5 instead of 100) with pytest.raises(ValueError): s = InvertedEncoding2D(stim_xlim=[-1, 1], stim_ylim=[-1, 1], stimulus_resolution=10, @@ -119,19 +120,33 @@ def test_modify_2d_properties(): stimulus_resolution=res, chan_xlim=bds, chan_ylim=bds, channels=channels) with pytest.raises(ValueError): - s.set_params(n_channels=nchan - 1) + s = s.set_params(n_channels=nchan - 1) assert s, "Invalid InvertedEncoding2D instance" with pytest.raises(ValueError): - s.set_params(xp=np.random.rand(npix - 10)) + s = s.set_params(xp=np.random.rand(npix - 10)) assert s, "Invalid InvertedEncoding2D instance" with pytest.raises(ValueError): - s.set_params(stim_fov=[[0, 1], [0, -1]]) + s = s.set_params(stim_fov=[[0, 1], [0, -1]]) assert s, "Invalid InvertedEncoding2D instance" with pytest.raises(ValueError): - s.set_params(stim_fov=[[0, 1]]) + s = s.set_params(stim_fov=[[0, 1]]) + assert s, "Invalid InvertedEncoding2D instance" + with pytest.raises(ValueError): + s = s.set_params(stim_fov=[[0], [0, 1]]) assert s, "Invalid InvertedEncoding2D instance" +# Test that you can get object properties +def test_get_2d_params(): + bds = [-1, 1] + res = 10 + s = InvertedEncoding2D(stim_xlim=bds, stim_ylim=bds, + stimulus_resolution=res) + param_out = s.get_params() + assert np.all(param_out.get('stim_fov')[0] == bds) + assert param_out.get('xp').size == res*res + + # Test helper function to create 2D cosine def test_2d_cos(): nchan = 8 @@ -267,10 +282,36 @@ def test_cannot_fit_2d_data(): iem_2d.fit(Xd.transpose(), yd) +# Ill conditioned data matrix will raise error def test_ill_conditioned_2d_train_data(): + with pytest.raises(ValueError): + Xt = np.ones((nobs, nvox)) + y = np.random.rand(nobs, 2) + iem_2d.fit(Xt, y) + + +# Ill conditioned channel activations C will raise runtime warning +def test_ill_conditioned_2d_channel_activations(): + with pytest.raises(RuntimeWarning): + Xt = np.random.rand(nobs, nvox) + y = np.ones((nobs, 2)) + iem_2d.fit(Xt, y) + + +# Ill conditioned weight matrix will raise error +def test_ill_conditioned_2d_weights(): with pytest.raises(ValueError): Xt = np.random.rand(nobs, nvox) - iem_2d.fit(Xt, np.hstack((np.random.rand(nobs), np.random.rand(nobs)))) + y = np.random.rand(nobs, 2) + iem_2d.fit(Xt, y) + + +# Not enough observations will trigger error +def test_insufficient_2d_data(): + with pytest.raises(ValueError): + Xt = np.random.rand(10, nvox) + y = np.random.rand(10, 2) + iem_2d.fit(Xt, y) # Test case when # of observations are not matched btwn data & labels @@ -481,6 +522,7 @@ def test_stimulus_mask_shift_positive(): def test_can_get_params(): s = InvertedEncoding1D() param_out = s.get_params() + assert param_out.get('channel_exp') == 5 logger.info('Returned Parameters: ' + str(param_out.get('n_channels')) + ', ' + str(param_out.get('range_start')) + From baf4111e5106d897abe6661b6590e45cf497d4e8 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Sat, 10 Oct 2020 11:32:26 -0700 Subject: [PATCH 34/39] fixed pytest check for RuntimeWarning. Removed randomness in sqgrid test. --- tests/reconstruct/test_iem.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 9915f8223..91c9682cb 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -191,10 +191,8 @@ def test_square_basis_grid(): assert centers.shape[0] == nchan*nchan xspacing = np.round(np.diff(centers[:, 0]), 5) yspacing = np.round(np.diff(centers[:, 1]), 5) - assert xspacing[0] == xspacing[np.random.randint(nchan*nchan)] == \ - xspacing[-1] - assert yspacing[0] == yspacing[np.random.randint(nchan * nchan)] == \ - yspacing[-1] + assert xspacing[0] == xspacing[28] == xspacing[-1] + assert yspacing[0] == yspacing[25] == yspacing[-1] def test_triangular_basis_grid(): @@ -290,12 +288,10 @@ def test_ill_conditioned_2d_train_data(): iem_2d.fit(Xt, y) -# Ill conditioned channel activations C will raise runtime warning +# Ill conditioned channel activations C will raise warning def test_ill_conditioned_2d_channel_activations(): - with pytest.raises(RuntimeWarning): - Xt = np.random.rand(nobs, nvox) - y = np.ones((nobs, 2)) - iem_2d.fit(Xt, y) + with pytest.warns(RuntimeWarning): + C = iem_2d._define_trial_activations(np.ones((nobs, 2))) # Ill conditioned weight matrix will raise error From bf813c307dda93195dac41f3b9e571e29280f47f Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Sat, 10 Oct 2020 11:35:30 -0700 Subject: [PATCH 35/39] fixed numerical issues in size conversion tests. added matrix rank assertion for channel activation test. --- tests/reconstruct/test_iem.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 91c9682cb..10506f6ab 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -177,9 +177,9 @@ def test_2d_cos_size_fcns(): stimulus_resolution=10) fwhm = imodel._2d_cosine_sz_to_fwhm(s) s2 = imodel._2d_cosine_fwhm_to_sz(fwhm) - assert s == s2 + assert np.isclose(s, s2) fwhm2 = imodel._2d_cosine_sz_to_fwhm(s2) - assert fwhm == fwhm2 + assert np.isclose(fwhm, fwhm2) def test_square_basis_grid(): @@ -292,6 +292,7 @@ def test_ill_conditioned_2d_train_data(): def test_ill_conditioned_2d_channel_activations(): with pytest.warns(RuntimeWarning): C = iem_2d._define_trial_activations(np.ones((nobs, 2))) + assert np.linalg.matrix_rank(C) == 1 # Ill conditioned weight matrix will raise error From ef53702adbec64ddabcdb2539e95a77fd8aee68c Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Mon, 12 Oct 2020 15:43:34 -0700 Subject: [PATCH 36/39] added copyright & licensing for Intel --- brainiak/reconstruct/iem.py | 4 ++++ tests/reconstruct/test_iem.py | 7 +++++++ 2 files changed, 11 insertions(+) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 8e81d90fb..92b7d61c6 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -11,6 +11,10 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. +# +# Copyright 2020 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + """Inverted Encoding Model (IEM) Method to decode and reconstruct features from data. diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py index 10506f6ab..eb4ec6e3a 100644 --- a/tests/reconstruct/test_iem.py +++ b/tests/reconstruct/test_iem.py @@ -11,6 +11,13 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. +# +# Copyright 2020 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +# Authors: David Huberdeau (Yale University) & +# Peter Kok (Yale University), 2018 & +# Vy Vo (Intel Corp., UCSD), 2019 import pytest import numpy as np From 6f01c03d9c836c52c42b965048e453ded55a96c6 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Mon, 12 Oct 2020 16:57:23 -0700 Subject: [PATCH 37/39] added input parameter details in InvertedEncoding2D init. Fixed other docstrings. --- brainiak/reconstruct/iem.py | 47 +++++++++++++++++++++++++++++++++---- 1 file changed, 43 insertions(+), 4 deletions(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index 92b7d61c6..e0d17a7aa 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -40,6 +40,9 @@ written to give some flexibility compared to the specific instances in Kok, 2013 & in Brouwer, 2009. Users can set the number of basis functions, or channels, and the range of possible feature values. + + There are separate classes for reconstructing feature values in a + 1-dimensional (1D) space or in a 2-dimensional (2D) space. """ # Authors: David Huberdeau (Yale University) & @@ -65,8 +68,8 @@ class InvertedEncoding1D(BaseEstimator): """Basis function-based reconstruction method Inverted encoding models (alternatively known as forward models) are used - to reconstruct a feature represented in a 1-dimensional (1D) space, - e.g. color of a stimulus, from patterns across voxels in functional data. + to reconstruct a feature represented in some N-dimensional space, here 1D, + (e.g. color of a stimulus) from patterns across voxels in functional data. The model uses n_channels number of idealized basis functions and assumes that the transformation from stimulus feature (e.g. color) to basis function is one- to-one and invertible. The response of a voxel is @@ -161,6 +164,8 @@ class InvertedEncoding1D(BaseEstimator): W_: sklearn.linear_model model containing weight matrix that relates estimated channel responses to response amplitude data + + See get_params() for the rest of the attributes. """ def __init__(self, n_channels=6, channel_exp=5, @@ -460,8 +465,8 @@ class InvertedEncoding2D(BaseEstimator): """Basis function-based reconstruction method Inverted encoding models (alternatively known as forward models) are used - to reconstruct a feature represented in a 2-dimensional (2D) space, - e.g. position on a projector screen, from patterns across voxels in + to reconstruct a feature represented in a N-dimensional space, here 2D, + (e.g. position on a projector screen) from patterns across voxels in functional data. The model uses some number of idealized basis functions that cover the 2D space, and assumes that the transformation from stimulus feature (e.g. 2D spatial position) to basis function is one- @@ -563,11 +568,45 @@ class InvertedEncoding2D(BaseEstimator): W_: sklearn.linear_model containing weight matrix that relates estimated channel responses to response data + + See get_params() for the rest of the attributes. """ def __init__(self, stim_xlim, stim_ylim, stimulus_resolution, stim_radius=None, chan_xlim=None, chan_ylim=None, channels=None, channel_exp=7): + """Defines a 2D inverted encoding model object. + + While the parameters defining the domain in which to reconstruct + the stimuli are required (e.g. all `stim_*` inputs), the parameters + to define the channels (`chan*`) are optional, in case the user + wishes to define their own channels (a.k.a basis functions). + + + Parameters + ---------- + stim_xlim: sequence of 2 float values, specifying the lower & upper + limits on the horizontal axis, respectively. + stim_ylim: sequence of 2 float values, specifying the lower & upper + limits on the vertical axis, respectively. + stimulus_resolution: a float or sequence of 2 floats, specifying the + number of pixels that exist in the x- and y- directions. + stim_radius: float, default None. The radius in pixels, assuming that + the stimulus is circular. If None, the user must either define it + before running fit(), or pass in a custom C in B = W*C. + chan_xlim: sequence of 2 float values, default None. Specifies the + lower & upper limits of the channels in the horizontal axis. If + None, the user must define this before using the class functions + to create basis functions, or pass in custom-defined channels. + chan_ylim: sequence of 2 float values, default None. Specifies the + lower & upper limits of the channels in the vertical axis. If + None, the user must define this before using the class functions + to create basis functions, or pass in custom-defined channels. + channel_exp: float or int, default None. The exponent for a + sinusoidal basis function. If None, it must be set before the + channels or defined, or pass in custom-defined channels. + + """ # Automatically expand stimulus_resolution if only one value is given. # This will create a square field of view (FOV) for the # reconstruction. From 930b380b0fdb055e0e2c15084ef463938b080e24 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Mon, 12 Oct 2020 17:17:26 -0700 Subject: [PATCH 38/39] Added detail about different scoring functions. Removed whitespace. --- brainiak/reconstruct/iem.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py index e0d17a7aa..92f6304ec 100644 --- a/brainiak/reconstruct/iem.py +++ b/brainiak/reconstruct/iem.py @@ -164,7 +164,7 @@ class InvertedEncoding1D(BaseEstimator): W_: sklearn.linear_model model containing weight matrix that relates estimated channel responses to response amplitude data - + See get_params() for the rest of the attributes. """ @@ -735,6 +735,9 @@ def score(self, X, y): """Calculate error measure of prediction, assuming that the predicted feature is at the maximum of the reconstructed values. + To score the reconstructions against expected features defined in the + stimulus domain (i.e. in pixels), see score_against_reconstructed(). + Parameters ---------- X: numpy matrix of voxel activation from new data @@ -759,6 +762,8 @@ def score_against_reconstructed(self, X, y, metric="euclidean"): some observations X, and expected features y. Expected features must also be in the pixel stimulus domain. + To score the reconstructions against the expected maxima, see score(). + Parameters ---------- X: numpy matrix of voxel activation from new data From be66aca972b56505f0bd6dd938c91dbf6a16e638 Mon Sep 17 00:00:00 2001 From: Vy Vo Date: Mon, 12 Oct 2020 17:18:12 -0700 Subject: [PATCH 39/39] More complete attribution to dataset / IEM tutorial authors. Clarified some details in markdown text. --- examples/reconstruct/iem2d_example.ipynb | 27 ++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/examples/reconstruct/iem2d_example.ipynb b/examples/reconstruct/iem2d_example.ipynb index 520a53fdf..9a14dbe8c 100644 --- a/examples/reconstruct/iem2d_example.ipynb +++ b/examples/reconstruct/iem2d_example.ipynb @@ -18,11 +18,17 @@ "source": [ "In this example, we will assume that the stimuli are circular checkerboards presented in 2-dimensional visual space. We will build an encoding model that has a grid of 6x6 channels, or basis functions, which also span this 2D space.\n", "\n", - "The dataset, as described by the IEM tutorial written by Thomas Sprague & John Serences for MATLAB (https://github.com/tommysprague/IEM-tutorial):\n", + "Read the documentation for the module to get further details on the IEM.\n", + "\n", + "### About the data\n", + "The data and content of this notebook are adapted from the IEM tutorial written by Thomas Sprague & John Serences for MATLAB (https://github.com/tommysprague/IEM-tutorial).\n", "\n", "\"Participants viewed peripheral flickering checkerboard stimuli presented at a range of contrasts (0-70%, logarithmically spaced) while performing either a demanding target detection task (contrast change) at the stimulus position (\"attend stimulus\" condition) or at the fixation point (\"attend fixation\" condition). The stimuli appeared randomly on the left or right side of the screen. Targets appeared rarely, and trials in which targets do appear are not included in analyses. Thus, sensory conditions are perfectly equated across the attend stimulus and the attend fixation conditions.\n", "\n", - "In addition to this main attention task, paricipants also performed a \"spatial mapping\" task in which they viewed small checkerboard discs presented at different positions on the screen while they performed a demanding fixation task (contrast change detection).\"" + "In addition to this main attention task, paricipants also performed a \"spatial mapping\" task in which they viewed small checkerboard discs presented at different positions on the screen while they performed a demanding fixation task (contrast change detection).\"\n", + "\n", + "These data were collected by Thomas Sprague & Sirawaj Itthipuripat, for the following paper:\n", + "Itthipuripat, S., Sprague, T.,C., Serences, J.T. 2019. Functional MRI and EEG Index Complementary Attentional Modulations. J. Neurosci. 31:6162-6179. Data available at https://osf.io/savfp/." ] }, { @@ -176,6 +182,13 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check how well the basis functions cover the stimulus domain, we can sum across all the basis functions." + ] + }, { "cell_type": "code", "execution_count": 77, @@ -278,7 +291,7 @@ "source": [ "## Average feature reconstructions across trials\n", "\n", - "In this experiment, we are not specifically interested in separating trials by whether stimuli were on the left or the right. Instead, we're interested in how the activation in the model-based reconstruction varies with the experimental manipulation of contrast and attended location. For the sake of visualization and quantification, we can simply average across the trials of interest. Below we're separate the trials by contrast and attention location, but average across trials where the stimulus appeared on the left side of the screen and the target was not present (to ensure that overall contrast is identical across averaged trials)." + "In this experiment, we are not specifically interested in separating trials by whether stimuli were on the left or the right. Instead, we're interested in how the activation in the model-based reconstruction varies with the experimental manipulation of contrast and attended location. For the sake of visualization and quantification, we can simply average across the trials of interest. Below we separated the trials by contrast and attention location, but averaged across trials where the stimulus appeared on the left side of the screen and the target was not present (to ensure that overall contrast is identical across averaged trials)." ] }, { @@ -311,7 +324,7 @@ "Finally, we plot the data as a function of:\n", " \n", "1) whether subjects were attending to the stimulus or fixation, and\n", - "2) the contrast of the stimulus (across six levels)" + "2) the contrast of the stimulus (across six levels)." ] }, { @@ -357,7 +370,9 @@ "source": [ "These data suggest that increasing the contrast leads to stronger activation of the stimulus. They also suggest that the effect of attention is greatest at low contrast levels -- e.g. at contrast level 3, we see a clear enhancement when the participant is attending to the stimulus compared to when they are attending fixation.\n", "\n", - "However, since this is single-participant data, these effects should be quantified across a group of subjects." + "However, since this is single-participant data, these effects should be quantified across a group of subjects.\n", + "\n", + "Full results from these manipulations across a group of subjects can be seen in Itthipuripat, Sprague, Serences 2019." ] } ], @@ -377,7 +392,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.9" } }, "nbformat": 4,