def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingCenterSurroundStimulus') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'surround_orientation' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"surround_orientation") for k in self.tc_dict.keys(): sis = [] surround_tuning=[] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): ors = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) d={} for o,v in zip(ors,values): d[o] = v sis.append(d[0] / d[numpy.pi/2]) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingCenterSurroundStimulus') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'surround_orientation' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"surround_orientation") for k in self.tc_dict.keys(): sis = [] surround_tuning=[] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): ors = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) d=OrderedDict() for o,v in zip(ors,values): d[o] = v sis.append(d[0] / d[numpy.pi/2]) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingDisk') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'radius' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"radius") for k in self.tc_dict.keys(): crf_sizes = [] supp_sizes= [] sis = [] max_responses=[] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): rads = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) # sort them based on radiuses rads , values = zip(*sorted(zip(rads,values))) max_response = numpy.max(values) crf_index = numpy.argmax(values) crf_size = rads[crf_index] if crf_index < len(values)-1: supp_index = crf_index+numpy.argmax(values[crf_index+1:])+1 else: supp_index = len(values)-1 supp_size = rads[supp_index] if values[crf_index] != 0: si = (values[crf_index]-values[supp_index])/values[crf_index] else: si = 0 crf_sizes.append(crf_size) supp_sizes.append(supp_size) sis.append(si) max_responses.append(max_response) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(max_responses,self.parameters.neurons,self.st[0].params()["radius"].units,value_name = 'Max. response of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(crf_sizes,self.parameters.neurons,self.st[0].params()["radius"].units,value_name = 'Max. facilitation radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(supp_sizes,self.parameters.neurons,self.st[0].params()["radius"].units,value_name = 'Max. suppressive radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore, identifier='PerNeuronValue') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id', 'sheet_name']) textures = list(set([MozaikParametrized.idd(ads.stimulus_id).texture for ads in dsv.get_analysis_result()])) samples = list(set([MozaikParametrized.idd(ads.stimulus_id).sample for ads in dsv.get_analysis_result()])) trials = list(set([MozaikParametrized.idd(ads.stimulus_id).trial for ads in dsv.get_analysis_result()])) for sheet in self.parameters.sheet_list: mean_rates = [] #This is a 4D array where we will store the firing rates of each neurons for each trial of each sample of each texture family for texture in textures: mean_rates_texture = [] dsv_tmp = queries.param_filter_query(dsv,identifier='PerNeuronValue',sheet_name=sheet,st_texture=texture,st_stats_type=1) for sample in samples: mean_rates_sample = [] for trial in trials: pnv = queries.param_filter_query(dsv_tmp,identifier='PerNeuronValue',st_sample=sample,st_trial=trial).get_analysis_result()[0] mean_rates_sample.append(pnv.values) mean_rates_texture.append(mean_rates_sample) mean_rates.append(mean_rates_texture) global_averaged_rates = numpy.mean(mean_rates, axis = (0,1,2)) #Calculating the global averaged firing rates for each neurons accross each texture family, samples and trials textures_averaged_rates = numpy.mean(mean_rates, axis = (1,2)) #Calculating the firing rates of each neurons for each texture family by averaging accross samples and trials samples_averaged_rates = numpy.mean(mean_rates, axis = 2) #Calculating the firing rates of each neurons for each sample by averaging accross trials SStextures = len(trials) * len(samples) * numpy.sum((textures_averaged_rates - global_averaged_rates)**2, axis=0) #Compute the Anova sum of squares accross texture families SSsamples = len(trials) * numpy.sum((numpy.transpose(samples_averaged_rates,(1,0,2)) - textures_averaged_rates)**2, axis=(0,1)) #Compute the Anova sum of squares accross samples SStrials = numpy.sum((numpy.transpose(mean_rates,(2,0,1,3)) - samples_averaged_rates)**2, axis=(0,1,2)) #Compute the Anova sum of squares accross trials (residuals) SStotal = numpy.sum((mean_rates - global_averaged_rates)**2, axis=(0,1,2)) #Compute tha Anova total sum of squares #We compute the mean squares of the nested Anova MStextures = SStextures/(len(textures)-1) MSsamples = SSsamples/(len(textures) * (len(samples) - 1)) MStrials = SStrials/(len(textures) * len(samples) * (len(trials) - 1)) #We compute the R-squared for each factor and for the residuals RsquaredTextures = SStextures/SStotal RsquaredSamples = SSsamples/SStotal RsquaredTrials = SStrials/SStotal #The variance ratio is the F statistic of the nested Anova varianceRatio = MStextures/MSsamples st = MozaikParametrized.idd(pnv.stimulus_id) setattr(st,'stats_type',None) setattr(st,'trial',None) setattr(st,'sample',None) setattr(st,'texture',None) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(varianceRatio,pnv.ids,None,value_name = "Texture variance ratio",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(RsquaredTextures * 100,pnv.ids,value_units=qt.percent,value_name = "Texture r-squared",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(RsquaredSamples * 100,pnv.ids,value_units=qt.percent,value_name = "Sample r-squared",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(RsquaredTrials * 100,pnv.ids,value_units=qt.percent,value_name = "Trial r-squared",sheet_name=sheet,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(st)))
def subplot(self, subplotspec): plots = {} gs = gridspec.GridSpecFromSubplotSpec(1,2, subplot_spec=subplotspec,hspace=1.0, wspace=1.0) var_gr = 0 var_ni = 0 std_gr = 0 std_ni = 0 orr = list(set([MozaikParametrized.idd(s).orientation for s in queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',st_contrast=100).get_stimuli()])) l4_exc_or = self.datastore.get_analysis_result(identifier='PerNeuronValue',value_name = 'LGNAfferentOrientation', sheet_name = self.parameters.sheet_name) # lets calculate spont. activity trial to trial variability # we assume that the spontaneous activity had already the spikes removed dsv = queries.param_filter_query(self.datastore,st_name='InternalStimulus',st_direct_stimulation_name='None',sheet_name=self.parameters.sheet_name,analysis_algorithm='ActionPotentialRemoval',ads_unique=True) ids = dsv.get_analysis_result()[0].ids sp = {} for idd in ids: assert len(dsv.get_analysis_result()) == 1 s = dsv.get_analysis_result()[0].get_asl_by_id(idd).magnitude sp[idd] = 1/numpy.mean(numpy.std([s[i*int(len(s)/10):(i+1)*int(len(s)/10)] for i in xrange(0,10)],axis=0,ddof=1)) #sp[idd] = 1/numpy.std(s,ddof=1) print sp[ids[1]] #lets calculate the mean of trial-to-trial variances across the neurons in the datastore for gratings dsv = queries.param_filter_query(self.datastore,st_name='FullfieldDriftingSinusoidalGrating',sheet_name=self.parameters.sheet_name,st_contrast=100,analysis_algorithm='TrialVariability',y_axis_name='Vm (no AP) trial-to-trial variance') assert queries.equal_ads(dsv, except_params=['stimulus_id']) ids = dsv.get_analysis_result()[0].ids var_gr_ind = [] logger.info("AA") logger.info(str([sp[i] for i in ids])) for i in ids: # find the or pereference of the neuron o = orr[numpy.argmin([circular_dist(o,l4_exc_or[0].get_value_by_id(i),numpy.pi) for o in orr])] assert len(queries.param_filter_query(dsv,st_orientation=o,ads_unique=True).get_analysis_result())==1 a = 1/numpy.mean(numpy.sqrt(queries.param_filter_query(dsv,st_orientation=o,ads_unique=True).get_analysis_result()[0].get_asl_by_id(i).magnitude)) var_gr = var_gr + a / sp[i] var_gr_ind.append(a / sp[i]) std_gr = std_gr + a var_gr = var_gr / len(ids) std_gr = std_gr / len(ids) logger.info(str(var_gr_ind)) #lets calculate the mean of trial-to-trial variances across the neurons in the datastore for natural images dsv = queries.param_filter_query(self.datastore,st_name='NaturalImageWithEyeMovement',sheet_name=self.parameters.sheet_name,y_axis_name='Vm (no AP) trial-to-trial variance',ads_unique=True) var_ni_ind = [1/numpy.mean(numpy.sqrt(dsv.get_analysis_result()[0].get_asl_by_id(i).magnitude)) / sp[i] for i in ids] var_ni = numpy.mean(var_ni_ind) plots['Bar'] = (BarComparisonPlot({"NI" : var_ni*100.0, "GR" : var_gr*100.0}),gs[0,0],{}) plots['Scatter'] = (ScatterPlot(var_gr_ind*100, var_ni_ind*100),gs[0,1],{'x_label' : 'GR', 'y_label' : 'NI','identity_line' : True}) return plots
def perform_analysis(self): for sheet in self.datastore.sheets(): # Load up spike trains for the right sheet and the corresponding # stimuli, and transform spike trains into psth dsv = queries.param_filter_query(self.datastore,identifier='AnalogSignalList',sheet_name=sheet,analysis_algorithm='PSTH',st_name='FullfieldDriftingSinusoidalGrating') assert queries.equal_ads(dsv,except_params=['stimulus_id']) , "It seems PSTH computed in different ways are present in datastore, ModulationRatio can accept only one" psths = dsv.get_analysis_result() st = [MozaikParametrized.idd(p.stimulus_id) for p in psths] # average across trials psths, stids = colapse(psths,st,parameter_list=['trial'],func=neo_sum,allow_non_identical_objects=True) # retrieve the computed orientation preferences pnvs = self.datastore.get_analysis_result(identifier='PerNeuronValue', sheet_name=sheet, value_name='orientation preference') if len(pnvs) != 1: logger.error("ERROR: Expected only one PerNeuronValue per sheet " "with value_name 'orientation preference' in datastore, got: " + str(len(pnvs))) return None or_pref = pnvs[0] # find closest orientation of grating to a given orientation preference of a neuron # first find all the different presented stimuli: ps = OrderedDict() for s in st: ps[MozaikParametrized.idd(s).orientation] = True ps = ps.keys() # now find the closest presented orientations closest_presented_orientation = [] for i in xrange(0, len(or_pref.values)): circ_d = 100000 idx = 0 for j in xrange(0, len(ps)): if circ_d > circular_dist(or_pref.values[i], ps[j], numpy.pi): circ_d = circular_dist(or_pref.values[i], ps[j], numpy.pi) idx = j closest_presented_orientation.append(ps[idx]) closest_presented_orientation = numpy.array(closest_presented_orientation) # collapse along orientation - we will calculate MR for each # parameter combination other than orientation d = colapse_to_dictionary(psths, stids, "orientation") for (st, vl) in d.items(): # here we will store the modulation ratios, one per each neuron modulation_ratio = [] f0 = [] f1 = [] ids = [] frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).getParams()['temporal_frequency'].units for (orr, ppsth) in zip(vl[0], vl[1]): for j in numpy.nonzero(orr == closest_presented_orientation)[0]: if or_pref.ids[j] in ppsth.ids: a = or_pref.ids[j] mr,F0,F1 = self._calculate_MR(ppsth.get_asl_by_id(or_pref.ids[j]).flatten(),frequency) modulation_ratio.append(mr) f0.append(F0) f1.append(F1) ids.append(or_pref.ids[j]) logger.debug('Adding PerNeuronValue:' + str(sheet)) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(modulation_ratio, ids, qt.dimensionless, value_name='Modulation ratio' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(f0, ids, qt.dimensionless, value_name='F0' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(f1, ids, qt.dimensionless, value_name='F1' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) import pylab pylab.figure() pylab.hist(modulation_ratio)
def perform_analysis(self): dsv = queries.param_filter_query(self.datastore,identifier='PerNeuronValue',sheet_name=self.parameters.sheet_name,st_name='DriftingSinusoidalGratingDisk') if len(dsv.get_analysis_result()) == 0: return assert queries.ads_with_equal_stimulus_type(dsv) assert queries.equal_ads(dsv,except_params=['stimulus_id']) self.pnvs = dsv.get_analysis_result() # get stimuli self.st = [MozaikParametrized.idd(s.stimulus_id) for s in self.pnvs] # transform the pnvs into a dictionary of tuning curves according along the 'radius' parameter # also make sure they are ordered according to the first pnv's idds self.tc_dict = colapse_to_dictionary([z.get_value_by_id(self.parameters.neurons) for z in self.pnvs],self.st,"radius") for k in self.tc_dict.keys(): crf_sizes = [] supp_sizes= [] sis = [] max_responses=[] csis = [] # we will do the calculation neuron by neuron for i in xrange(0,len(self.parameters.neurons)): rads = self.tc_dict[k][0] values = numpy.array([a[i] for a in self.tc_dict[k][1]]) # sort them based on radiuses rads , values = zip(*sorted(zip(rads,values))) max_response = numpy.max(values) crf_index = numpy.argmax(values) crf_size = rads[crf_index] if crf_index < len(values)-1: supp_index = crf_index+numpy.argmin(values[crf_index+1:])+1 else: supp_index = len(values)-1 supp_size = rads[supp_index] if supp_index < len(values)-1: cs_index = supp_index+numpy.argmax(values[supp_index+1:])+1 else: cs_index = len(values)-1 if values[crf_index] != 0: si = (values[crf_index]-values[supp_index])/values[crf_index] else: si = 0 if values[cs_index] != 0: csi = (values[cs_index]-values[supp_index])/values[crf_index] else: csi = 0 crf_sizes.append(crf_size) supp_sizes.append(supp_size) sis.append(si) max_responses.append(max_response) csis.append(csi) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(max_responses,self.parameters.neurons,self.st[0].getParams()["radius"].units,value_name = 'Max. response of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(crf_sizes,self.parameters.neurons,self.st[0].getParams()["radius"].units,value_name = 'Max. facilitation radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(supp_sizes,self.parameters.neurons,self.st[0].getParams()["radius"].units,value_name = 'Max. suppressive radius of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(sis,self.parameters.neurons,None,value_name = 'Suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k))) self.datastore.full_datastore.add_analysis_result(PerNeuronValue(csis,self.parameters.neurons,None,value_name = 'Counter-suppression index of ' + self.pnvs[0].value_name ,sheet_name=self.parameters.sheet_name,tags=self.tags,period=None,analysis_algorithm=self.__class__.__name__,stimulus_id=str(k)))
def perform_analysis(self): for sheet in self.datastore.sheets(): # Load up spike trains for the right sheet and the corresponding # stimuli, and transform spike trains into psth print sheet self.datastore.print_content() dsv = queries.param_filter_query(self.datastore,identifier='AnalogSignalList',sheet_name=sheet,analysis_algorithm='PSTH',st_name='FullfieldDriftingSinusoidalGrating') dsv.print_content() assert queries.equal_ads(dsv,except_params=['stimulus_id']) , "It seems PSTH computed in different ways are present in datastore, ModulationRatio can accept only one" psths = dsv.get_analysis_result() st = [MozaikParametrized.idd(p.stimulus_id) for p in psths] # average across trials psths, stids = colapse(psths,st,parameter_list=['trial'],func=neo_sum,allow_non_identical_objects=True) # retrieve the computed orientation preferences pnvs = self.datastore.get_analysis_result(identifier='PerNeuronValue', sheet_name=sheet, value_name='orientation preference') if len(pnvs) != 1: logger.error("ERROR: Expected only one PerNeuronValue per sheet " "with value_name 'orientation preference' in datastore, got: " + str(len(pnvs))) return None or_pref = pnvs[0] # find closest orientation of grating to a given orientation preference of a neuron # first find all the different presented stimuli: ps = {} for s in st: ps[MozaikParametrized.idd(s).orientation] = True ps = ps.keys() print ps # now find the closest presented orientations closest_presented_orientation = [] for i in xrange(0, len(or_pref.values)): circ_d = 100000 idx = 0 for j in xrange(0, len(ps)): if circ_d > circular_dist(or_pref.values[i], ps[j], numpy.pi): circ_d = circular_dist(or_pref.values[i], ps[j], numpy.pi) idx = j closest_presented_orientation.append(ps[idx]) closest_presented_orientation = numpy.array(closest_presented_orientation) # collapse along orientation - we will calculate MR for each # parameter combination other than orientation d = colapse_to_dictionary(psths, stids, "orientation") for (st, vl) in d.items(): # here we will store the modulation ratios, one per each neuron modulation_ratio = [] ids = [] frequency = MozaikParametrized.idd(st).temporal_frequency * MozaikParametrized.idd(st).params()['temporal_frequency'].units for (orr, ppsth) in zip(vl[0], vl[1]): for j in numpy.nonzero(orr == closest_presented_orientation)[0]: if or_pref.ids[j] in ppsth.ids: modulation_ratio.append(self._calculate_MR(ppsth.get_asl_by_id(or_pref.ids[j]),frequency)) ids.append(or_pref.ids[j]) logger.debug('Adding PerNeuronValue:' + str(sheet)) self.datastore.full_datastore.add_analysis_result( PerNeuronValue(modulation_ratio, ids, qt.dimensionless, value_name='Modulation ratio' + '(' + psths[0].x_axis_name + ')', sheet_name=sheet, tags=self.tags, period=None, analysis_algorithm=self.__class__.__name__, stimulus_id=str(st))) import pylab pylab.figure() pylab.hist(modulation_ratio)