def __call__(self,**params_to_override): p = ParamOverrides(self,params_to_override) p.generators=[Gaussian(aspect_ratio=p.aspect_ratio,size=p.gaussian_size), UniformRandom(name=p.name, time_dependent=p.time_dependent, time_fn = p.time_fn)] return super(GaussianCloud,self).__call__(**p)
def __call__(self,output_fn,init_time=0,final_time=None,**params): p=ParamOverrides(self,params) if final_time is None: final_time=topo.sim.time() attrs = p.attrib_names if len(p.attrib_names)>0 else output_fn.attrib_names for a in attrs: pylab.figure(figsize=(6,4)) isint=pylab.isinteractive() pylab.ioff() pylab.grid(True) ylabel=p.ylabel pylab.ylabel(a+" "+ylabel) pylab.xlabel('Iteration Number') coords = p.units if len(p.units)>0 else output_fn.units for coord in coords: y_data=[y for (x,y) in output_fn.values[a][coord]] x_data=[x for (x,y) in output_fn.values[a][coord]] if p.raw==True: plot_data=zip(x_data,y_data) pylab.save(normalize_path(p.filename+a+'(%.2f, %.2f)' %(coord[0], coord[1])),plot_data,fmt='%.6f', delimiter=',') pylab.plot(x_data,y_data, label='Unit (%.2f, %.2f)' %(coord[0], coord[1])) (ymin,ymax)=p.ybounds pylab.axis(xmin=init_time,xmax=final_time,ymin=ymin,ymax=ymax) if isint: pylab.ion() pylab.legend(loc=0) p.title=topo.sim.name+': '+a p.filename_suffix=a self._generate_figure(p)
def __call__(self, **params_to_override): p = ParamOverrides(self, params_to_override) p.generators = [ Gaussian(aspect_ratio=p.aspect_ratio, size=p.gaussian_size), UniformRandom() ] return super(GaussianCloud, self).__call__(**p)
def __call__(self,**params): p=ParamOverrides(self,params) sheet = p.sheet for coordinate in p.coords: i_value,j_value=sheet.sheet2matrixidx(coordinate[0],coordinate[1]) pylab.figure(figsize=(7,7)) isint=pylab.isinteractive() pylab.ioff() pylab.ylabel('Response',fontsize='large') pylab.xlabel('%s (%s)' % (p.x_axis.capitalize(),p.unit),fontsize='large') pylab.title('Sheet %s, coordinate(x,y)=(%0.3f,%0.3f) at time %s' % (sheet.name,coordinate[0],coordinate[1],topo.sim.timestr())) p.title='%s: %s Tuning Curve' % (topo.sim.name,p.x_axis.capitalize()) self.first_curve=True for curve_label in sorted(sheet.curve_dict[p.x_axis].keys()): x_values,y_values,ticks=self._curve_values(i_value,j_value,sheet.curve_dict[p.x_axis][curve_label]) x_tick_values,ticks = self._reduce_ticks(ticks) labels = [self._format_x_tick_label(x) for x in ticks] pylab.xticks(x_tick_values, labels,fontsize='large') pylab.yticks(fontsize='large') p.plot_type(x_values, y_values, label=curve_label,lw=3.0) self.first_curve=False if isint: pylab.ion() if p.legend: pylab.legend(loc=2) self._generate_figure(p)
def __call__(self,mat,aspect=None,colorbar=True,**params): p=ParamOverrides(self,params) p.plot_type() pylab.figure(figsize=(5,5)) pylab.imshow(mat,interpolation='nearest',aspect=aspect) if colorbar and (mat.min()!= mat.max()): pylab.colorbar() self._generate_figure(p)
def __call__(self,data,colors=None,**params): p=ParamOverrides(self,params,allow_extra_keywords=True) pylab.figure(figsize=(4,2)) n,bins,bars = pylab.hist(data,**(p.extra_keywords())) # if len(bars)!=len(colors), any extra bars won't have their # colors changed, or any extra colors will be ignored. if colors: [bar.set_fc(color) for bar,color in zip(bars,colors)] self._generate_figure(p)
def __call__(self, features, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) self.features = features self._initialize_featureresponses(p) self._measure_responses(p) results = self._collate_results(p) if p.measurement_storage_hook: p.measurement_storage_hook(results) return results
def __call__(self, data, colors=None, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) fig = plt.figure(figsize=(4, 2)) n, bins, bars = plt.hist(data, **(p.extra_keywords())) # if len(bars)!=len(colors), any extra bars won't have their # colors changed, or any extra colors will be ignored. if colors: [bar.set_fc(color) for bar, color in zip(bars, colors)] self._generate_figure(p) return fig
def __call__(self, **params): p = ParamOverrides(self, params) name = p.plot_template.keys().pop(0) plot = make_template_plot(p.plot_template, p.sheet.views.Maps, p.sheet.xdensity, p.sheet.bounds, p.normalize, name=p.plot_template[name]) fig = plt.figure(figsize=(5, 5)) if plot: bitmap = plot.bitmap isint = plt.isinteractive( ) # Temporarily make non-interactive for plotting plt.ioff() # Turn interactive mode off plt.imshow(bitmap.image, origin='lower', interpolation='nearest') plt.axis('off') for (t, pref, sel, c) in p.overlay: v = plt.flipud(p.sheet.views.Maps[pref].view()[0]) if (t == 'contours'): plt.contour(v, [sel, sel], colors=c, linewidths=2) if (t == 'arrows'): s = plt.flipud(p.sheet.views.Maps[sel].view()[0]) scale = int(np.ceil(np.log10(len(v)))) X = np.array([x for x in xrange(len(v) / scale)]) v_sc = np.zeros((len(v) / scale, len(v) / scale)) s_sc = np.zeros((len(v) / scale, len(v) / scale)) for i in X: for j in X: v_sc[i][j] = v[scale * i][scale * j] s_sc[i][j] = s[scale * i][scale * j] plt.quiver(scale * X, scale * X, -np.cos(2 * np.pi * v_sc) * s_sc, -np.sin(2 * np.pi * v_sc) * s_sc, color=c, edgecolors=c, minshaft=3, linewidths=1) p.title = '%s overlaid with %s at time %s' % (plot.name, pref, topo.sim.timestr()) if isint: plt.ion() p.filename_suffix = "_" + p.sheet.name self._generate_figure(p) return fig
def __call__(self, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) x_axis = p.x_axis.capitalize() vmap = p.sheet.views.Curves[x_axis.capitalize() + "Tuning"] time = vmap.range('Time')[1] curves = [] if vmap.dimensions(label=True) == 'X': for coord in p.coords: x, y = coord current_map = vmap[x, y, time, :, :, :] curve_map = current_map.sample(X=x, Y=y).collate( p.x_axis.capitalize()) curves.append(curve_map.overlay(p.group_by)) else: current_map = vmap[time, :, :, :] curve_map = current_map.sample(p.coords).to.curve( p.x_axis.capitalize(), 'Response') overlaid_curves = curve_map.overlay(p.group_by) if not isinstance(curves, NdLayout): curves = [overlaid_curves] figs = [] for coord, curve in zip(p.coords, curves): if isinstance(curve, HoloMap): curve = curve.last plot = OverlayPlot if isinstance(curve, CompositeOverlay) else CurvePlot fig = plot(curve, center=p.center, relative_labels=p.relative_labels, show_legend=p.legend)() self._generate_figure(p, fig) figs.append((coord, fig)) return figs
def __call__(self, **params_to_override): p = ParamOverrides(self, params_to_override) g_1 = Gaussian() g_2 = Gaussian() x_1 = g_1( orientation=p.orientation, bounds=p.bounds, xdensity=p.xdensity, ydensity=p.ydensity, offset=p.offset, size=p.size, aspect_ratio=p.aspect_ratio, x=p.x + 0.7 * np.cos(p.orientation) * p.cross * p.size * p.aspect_ratio, y=p.y + 0.7 * np.sin(p.orientation) * p.cross * p.size * p.aspect_ratio) x_2 = g_2(orientation=p.orientation + p.angle, bounds=p.bounds, xdensity=p.xdensity, ydensity=p.ydensity, offset=p.offset, size=p.size, aspect_ratio=p.aspect_ratio, x=p.x + 0.7 * np.cos(p.orientation + p.angle) * p.cross * p.size * p.aspect_ratio, y=p.y + 0.7 * np.sin(p.orientation + p.angle) * p.cross * p.size * p.aspect_ratio) return np.maximum(x_1, x_2)
def __call__(self, x, y, z, labels=["X", "Y", "Z"], type="wireframe", **params): p = ParamOverrides(self, params) from mpl_toolkits.mplot3d import axes3d fig = plt.figure() ax = axes3d.Axes3D(fig) if type == "wireframe": ax.plot_wireframe(x, y, z) elif type == "surface": ax.plot_surface(x, y, z) elif type == "contour": ax.contour3D(x, y, z) else: raise ValueError("Unknown plot type " + str(type)) ax.set_xlabel(labels[0]) ax.set_ylabel(labels[1]) ax.set_zlabel(labels[2]) self._generate_figure(p) return fig
def __call__(self,**params_to_override): """ Call the subclass's 'function' method on a rotated and scaled coordinate system. Creates and fills an array with the requested pattern. If called without any params, uses the values for the Parameters as currently set on the object. Otherwise, any params specified override those currently set on the object. """ p=ParamOverrides(self,params_to_override) # CEBERRORALERT: position parameter is not currently # supported. We should delete the position parameter or fix # this. # # position=params_to_override.get('position',None) if position # is not None: x,y = position self._setup_xy(p.bounds,p.xdensity,p.ydensity,p.x,p.y,p.orientation) fn_result = self.function(p) self._apply_mask(p,fn_result) result = p.scale*fn_result+p.offset for of in p.output_fns: of(result) return result
def __call__(self, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) x_axis = p.x_axis.capitalize() stack = p.sheet.views.Curves[x_axis.capitalize()+"Tuning"] time = stack.dim_range('Time')[1] curves = [] if stack.dimension_labels[0] == 'X': for coord in p.coords: x, y = coord current_stack = stack[x, y, time, :, :, :] curve_stack = current_stack.sample(X=x, Y=y).collate(p.x_axis.capitalize()) curves.append(curve_stack.overlay_dimensions(p.group_by)) else: current_stack = stack[time, :, :, :] curve_stack = current_stack.sample(coords=p.coords).collate(p.x_axis.capitalize()) overlaid_curves = curve_stack.overlay_dimensions(p.group_by) if not isinstance(curves, GridLayout): curves = [overlaid_curves] figs = [] for coord, curve in zip(p.coords,curves): fig = plt.figure() ax = plt.subplot(111) plot = DataPlot if isinstance(curve.last, DataOverlay) else CurvePlot plot(curve, center=p.center, relative_labels=p.relative_labels, show_legend=p.legend)(ax) self._generate_figure(p, fig) figs.append((coord, fig)) return figs
def __call__(self,mat,aspect=None,colorbar=True,**params): p=ParamOverrides(self,params) pylab.figure(figsize=(5,5)) p.plot_type() # Swap lbrt to lrbt to match pylab if p.extent is None: extent = None else: (l,b,r,t)=p.extent extent=(l,r,b,t) pylab.imshow(mat,interpolation='nearest',aspect=aspect,extent=extent) if colorbar and (mat.min()!= mat.max()): pylab.colorbar() self._generate_figure(p)
def __call__(self, mat, type="wireframe", **params): p = ParamOverrides(self, params) from mpl_toolkits.mplot3d import axes3d fig = plt.figure() ax = axes3d.Axes3D(fig) # Construct matrices for r and c values rn, cn = mat.shape c = np.outer(np.ones(rn), np.arange(cn * 1.0)) r = np.outer(np.arange(rn * 1.0), np.ones(cn)) if type == "wireframe": ax.plot_wireframe(r, c, mat) elif type == "surface": # Sometimes fails for no obvious reason ax.plot_surface(r, c, mat) elif type == "contour": # Works but not usually very useful ax.contour3D(r, c, mat) else: raise ValueError("Unknown plot type " + str(type)) ax.set_xlabel('R') ax.set_ylabel('C') ax.set_zlabel('Value') self._generate_figure(p)
def __call__(self, **params): p = ParamOverrides(self, params) fig = plt.figure(figsize=(5, 5)) # This one-liner works in Octave, but in matplotlib it # results in lines that are all connected across rows and columns, # so here we plot each line separately: # plt.plot(x,y,"k-",transpose(x),transpose(y),"k-") # Here, the "k-" means plot in black using solid lines; # see matplotlib for more info. isint = plt.isinteractive() # Temporarily make non-interactive for # plotting plt.ioff() for r, c in zip(p.y[::p.skip], p.x[::p.skip]): plt.plot(c, r, "k-") for r, c in zip(np.transpose(p.y)[::p.skip],np.transpose(p.x)[::p.skip]): plt.plot(c, r, "k-") # Force last line avoid leaving cells open if p.skip != 1: plt.plot(p.x[-1], p.y[-1], "k-") plt.plot(np.transpose(p.x)[-1], np.transpose(p.y)[-1], "k-") plt.xlabel('x') plt.ylabel('y') # Currently sets the input range arbitrarily; should presumably figure out # what the actual possible range is for this simulation (which would presumably # be the maximum size of any GeneratorSheet?). plt.axis(p.axis) if isint: plt.ion() self._generate_figure(p) return fig
def __call__(self, mat, aspect=None, colorbar=True, **params): p = ParamOverrides(self, params) fig = plt.figure(figsize=(5, 5)) p.plot_type() # Swap lbrt to lrbt to match pylab if p.extent is None: extent = None else: (l, b, r, t) = p.extent extent = (l, r, b, t) plt.imshow(mat, interpolation='nearest', aspect=aspect, extent=extent) if colorbar and (mat.min() != mat.max()): plt.colorbar() self._generate_figure(p) return fig
def __call__(self,**params): p=ParamOverrides(self,params) for template in p.plot_template: for sheet in topo.sim.objects(Sheet).values(): if getattr(sheet, "measure_maps", False): super(overlaid_plots, self).__call__(sheet=sheet, plot_template=template, overlay=p.overlay, normalize=p.normalize)
def __call__(self, **params_to_override): p = ParamOverrides(self, params_to_override) xsize, ysize = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity).shape xsize, ysize = int(round(xsize)), int(round(ysize)) xdisparity = int(round(xsize * p.xdisparity)) ydisparity = int(round(xsize * p.ydisparity)) dotsize = int(round(xsize * p.dotsize)) bigxsize = 2 * xsize bigysize = 2 * ysize ndots = int( round(p.dotdensity * (bigxsize + 2 * dotsize) * (bigysize + 2 * dotsize) / min(dotsize, xsize) / min(dotsize, ysize))) halfdot = floor(dotsize / 2) # Choose random colors and locations of square dots random_seed = p.random_seed numpy.random.seed(random_seed * 12 + random_seed * 99) col = numpy.where(numpy.random.random((ndots)) >= 0.5, 1.0, -1.0) numpy.random.seed(random_seed * 122 + random_seed * 799) xpos = numpy.floor( numpy.random.random((ndots)) * (bigxsize + 2 * dotsize)) - halfdot numpy.random.seed(random_seed * 1243 + random_seed * 9349) ypos = numpy.floor( numpy.random.random((ndots)) * (bigysize + 2 * dotsize)) - halfdot # Construct arrays of points specifying the boundaries of each # dot, cropping them by the big image size (0,0) to (bigxsize,bigysize) x1 = xpos.astype(numpy.int) x1 = choose(less(x1, 0), (x1, 0)) y1 = ypos.astype(numpy.int) y1 = choose(less(y1, 0), (y1, 0)) x2 = (xpos + (dotsize - 1)).astype(numpy.int) x2 = choose(greater(x2, bigxsize), (x2, bigxsize)) y2 = (ypos + (dotsize - 1)).astype(numpy.int) y2 = choose(greater(y2, bigysize), (y2, bigysize)) # Draw each dot in the big image, on a blank background bigimage = zeros((bigysize, bigxsize)) for i in range(ndots): bigimage[y1[i]:y2[i] + 1, x1[i]:x2[i] + 1] = col[i] result = p.offset + p.scale * bigimage[ (ysize / 2) + ydisparity:(3 * ysize / 2) + ydisparity, (xsize / 2) + xdisparity:(3 * xsize / 2) + xdisparity] for of in p.output_fns: of(result) return result
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) new_pattern = copy.copy(pattern) new_pattern.y = pattern.get_value_generator('y')+\ numbergen.UniformRandom(lbound=-p.position_bound_y, ubound=p.position_bound_y, seed=master_seed+35+pattern_number, name="YCoordinator"+str(pattern_number)) return new_pattern
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self,params,allow_extra_keywords=True) new_pattern=copy.copy(pattern) new_pattern.size=pattern.get_value_generator('size')*\ numbergen.UniformRandom(lbound=1, ubound=p.sf_spacing**(p.sf_max_channel-1), seed=master_seed+77+pattern_number, name="SpatialFrequencyCoordinator"+str(pattern_number)) return new_pattern
def __call__(self,**params): p=ParamOverrides(self,params) for sheet in topo.sim.objects(Sheet).values(): if ((p.xsheet_view_name in sheet.sheet_views) and (p.ysheet_view_name in sheet.sheet_views)): x = sheet.sheet_views[p.xsheet_view_name].view()[0] y = sheet.sheet_views[p.ysheet_view_name].view()[0] pylab.figure(figsize=(5,5)) # This one-liner works in Octave, but in matplotlib it # results in lines that are all connected across rows and columns, # so here we plot each line separately: # pylab.plot(x,y,"k-",transpose(x),transpose(y),"k-") # Here, the "k-" means plot in black using solid lines; # see matplotlib for more info. isint=pylab.isinteractive() # Temporarily make non-interactive for plotting pylab.ioff() for r,c in zip(y[::p.skip],x[::p.skip]): pylab.plot(c,r,"k-") for r,c in zip(transpose(y)[::p.skip],transpose(x)[::p.skip]): pylab.plot(c,r,"k-") # Force last line avoid leaving cells open if p.skip != 1: pylab.plot(x[-1],y[-1],"k-") pylab.plot(transpose(x)[-1],transpose(y)[-1],"k-") pylab.xlabel('x') pylab.ylabel('y') # Currently sets the input range arbitrarily; should presumably figure out # what the actual possible range is for this simulation (which would presumably # be the maximum size of any GeneratorSheet?). pylab.axis(p.axis) p.title='Topographic mapping to '+sheet.name+' at time '+topo.sim.timestr() if isint: pylab.ion() p.filename_suffix="_"+sheet.name self._generate_figure(p)
def __init__(self,inherent_features={},**params): """ If a dataset already and inherently includes certain features, a dictionary with feature-name:code-to-access-the-feature pairs should be supplied specifying how to select (e.g. from a set of images) the appropriate feature value. Any extra parameter values supplied here will be passed down to the feature_coordinators requested in features_to_vary. """ p=ParamOverrides(self,params,allow_extra_keywords=True) super(PatternCoordinator, self).__init__(**p.param_keywords()) self._feature_params = p.extra_keywords() self._inherent_features = inherent_features # And also, this key must be in feature_coordinators because _inherent_features # can have additional features such as i to support multiple images # TFALERT: Once spatial frequency (sf) is added, this will # cause warnings, because all image datasets will have a # spatial frequency inherent feature, but mostly we just # ignore that by having only a single size of DoG, which # discards all but a narrow range of sf. So the dataset will # have sf inherently, but that won't be an error or even # worthy of a warning. if(len((set(self._inherent_features.keys()) - set(self.features_to_vary)) & set(self.feature_coordinators.keys()))): self.warning('Inherent feature present which is not requested in features') self._feature_coordinators_to_apply = [] for feature, feature_coordinator in self.feature_coordinators.iteritems(): if feature in self.features_to_vary and feature not in self._inherent_features: # if it is a list, append each list item individually if isinstance(feature_coordinator,list): for individual_feature_coordinator in feature_coordinator: self._feature_coordinators_to_apply.append(individual_feature_coordinator) else: self._feature_coordinators_to_apply.append(feature_coordinator)
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self,params,allow_extra_keywords=True) assert(param.Dynamic.time_dependent), "param.Dynamic.time_dependent!=True for motion" assert(numbergen.RandomDistribution.time_dependent), "numbergen.RandomDistribution.time_dependent!=True for motion" moved_pattern = Sweeper(generator=copy.deepcopy(pattern), speed=p.speed, reset_period=p.reset_period, time_fn=p.time_fn) return moved_pattern
def __call__(self, **params_to_override): p = ParamOverrides(self, params_to_override) shape = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity).shape result = self._distrib(shape, p) self._apply_mask(p, result) for of in p.output_fns: of(result) return result
def __call__(self, vec, xvalues=None, style='-', label=None, **params): p = ParamOverrides(self, params) fig = plt.figure() if xvalues is not None: plt.plot(xvalues, vec, style, label=label) else: plt.plot(vec, style, label=label) plt.grid(True) self._generate_figure(p) return fig
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) new_pattern = copy.copy(pattern) new_pattern.orientation = pattern.get_value_generator('orientation')+\ numbergen.UniformRandom(lbound=-p.orientation_bound, ubound=p.orientation_bound, seed=master_seed+21+(0 if p.align_orientations else pattern_number), name=("OrientationCoordinator" + ('' if p.align_orientations else str(pattern_number))) ) return new_pattern
def __call__(self,**params_to_override): p = ParamOverrides(self,params_to_override) shape = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape result = p.scale*ones(shape, Float)+p.offset self._apply_mask(p,result) for of in p.output_fns: of(result) return result
def __call__(self, **params): p=ParamOverrides(self,params) name=p.plot_template.keys().pop(0) plot=make_template_plot(p.plot_template, p.sheet.views.Maps, p.sheet.xdensity,p.sheet.bounds, p.normalize,name=p.plot_template[name]) fig = plt.figure(figsize=(5,5)) if plot: bitmap=plot.bitmap isint=plt.isinteractive() # Temporarily make non-interactive for plotting plt.ioff() # Turn interactive mode off plt.imshow(bitmap.image,origin='lower',interpolation='nearest') plt.axis('off') for (t,pref,sel,c) in p.overlay: v = plt.flipud(p.sheet.views.Maps[pref].view()[0]) if (t=='contours'): plt.contour(v,[sel,sel],colors=c,linewidths=2) if (t=='arrows'): s = plt.flipud(p.sheet.views.Maps[sel].view()[0]) scale = int(np.ceil(np.log10(len(v)))) X = np.array([x for x in xrange(len(v)/scale)]) v_sc = np.zeros((len(v)/scale,len(v)/scale)) s_sc = np.zeros((len(v)/scale,len(v)/scale)) for i in X: for j in X: v_sc[i][j] = v[scale*i][scale*j] s_sc[i][j] = s[scale*i][scale*j] plt.quiver(scale*X, scale*X, -np.cos(2*np.pi*v_sc)*s_sc, -np.sin(2*np.pi*v_sc)*s_sc, color=c, edgecolors=c, minshaft=3, linewidths=1) p.title='%s overlaid with %s at time %s' %(plot.name,pref,topo.sim.timestr()) if isint: plt.ion() p.filename_suffix="_"+p.sheet.name self._generate_figure(p) return fig
def __call__(self, **params_to_override): p = ParamOverrides(self, params_to_override) if self.time_fn() >= self.last_time + p.reset_period: ## Returns early if within episode interval if self.time_fn( ) < self.last_time + p.reset_period + p.episode_interval: return p.episode_separator(xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds) else: self._advance_params() # JABALERT: Does not allow x, y, or direction to be passed in # to the call; fixing this would require implementing # inspect_value and force_new_dynamic_value (for # use in _advance_params) for ParamOverrides. # # Access parameter values without giving them new values assert ('x' not in params_to_override and 'y' not in params_to_override and 'direction' not in params_to_override) x = self.inspect_value('x') y = self.inspect_value('y') direction = self.inspect_value('direction') # compute how much time elapsed from the last reset # float(t) required because time could be e.g. gmpy.mpq t = float(self.time_fn() - self.last_time) ## CEBALERT: mask gets applied twice, both for the underlying ## generator and for this one. (leads to redundant ## calculations in current lissom_oo_or usage, but will lead ## to problems/limitations in the future). return p.generator( xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds, x=x + t * np.cos(direction) * p.speed + p.generator.x, y=y + t * np.sin(direction) * p.speed + p.generator.y, orientation=(direction - pi / 2) + p.generator.orientation)
def __call__(self, features, **params): """ Present the given input patterns and collate the responses. Responses are statistics on the distributions of measure for every unit, extracted by functions that are subclasses of DistributionStatisticFn, and could be specified in each feature with the preference_fn parameter, otherwise the default in self.preference_fn is used. """ p = ParamOverrides(self, params, allow_extra_keywords=True) self.features = features self._initialize_featureresponses(p) self._measure_responses(p) results = self._collate_results(p) if p.measurement_storage_hook: p.measurement_storage_hook(results) return results
def __init__(self, inherent_features=[], **params): """ If a dataset already and inherently includes certain features, a list with the inherent feature names should be supplied. Any extra parameter values supplied here will be passed down to the feature_coordinators requested in features_to_vary. """ p = ParamOverrides(self, params, allow_extra_keywords=True) super(PatternCoordinator, self).__init__(**p.param_keywords()) self._feature_params = p.extra_keywords() self._inherent_features = inherent_features # TFALERT: Once spatial frequency (sf) is added, this will # cause warnings, because all image datasets will have a # spatial frequency inherent feature, but mostly we just # ignore that by having only a single size of DoG, which # discards all but a narrow range of sf. So the dataset will # have sf inherently, but that won't be an error or even # worthy of a warning. if (len(set(self._inherent_features) - set(self.features_to_vary))): self.warning( 'Inherent feature present which is not requested in features') self._feature_coordinators_to_apply = [] for feature, feature_coordinator in self.feature_coordinators.items(): if feature in self.features_to_vary and feature not in self._inherent_features: # if it is a list, append each list item individually if isinstance(feature_coordinator, list): for individual_feature_coordinator in feature_coordinator: self._feature_coordinators_to_apply.append( individual_feature_coordinator) else: self._feature_coordinators_to_apply.append( feature_coordinator)
def __call__(self,**params_to_override): p=ParamOverrides(self,params_to_override) if self.time_fn() >= self.last_time + p.reset_period: ## Returns early if within episode interval if self.time_fn()<self.last_time+p.reset_period+p.episode_interval: return p.episode_separator(xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds) else: self._advance_params() # JABALERT: Does not allow x, y, or direction to be passed in # to the call; fixing this would require implementing # inspect_value and force_new_dynamic_value (for # use in _advance_params) for ParamOverrides. # # Access parameter values without giving them new values assert ('x' not in params_to_override and 'y' not in params_to_override and 'direction' not in params_to_override) x = self.inspect_value('x') y = self.inspect_value('y') direction = self.inspect_value('direction') # compute how much time elapsed from the last reset # float(t) required because time could be e.g. gmpy.mpq t = float(self.time_fn()-self.last_time) ## CEBALERT: mask gets applied twice, both for the underlying ## generator and for this one. (leads to redundant ## calculations in current lissom_oo_or usage, but will lead ## to problems/limitations in the future). return p.generator( xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds, x=x+t*np.cos(direction)*p.speed+p.generator.x, y=y+t*np.sin(direction)*p.speed+p.generator.y, orientation=(direction-pi/2)+p.generator.orientation)
def test_missing_key(self): overrides = ParamOverrides(self.po, {'name': 'B'}) try: overrides['doesnotexist'] except AttributeError: pass except: raise AssertionError( "ParamOverrides should give AttributeError when key can't be found." ) else: raise AssertionError( "Test supposed to lookup non-existent attribute and raise error." )
def __call__(self, **params): p = ParamOverrides(self, params) for sheet in topo.sim.objects(Sheet).values(): if ((p.xsheet_view_name in sheet.views.Maps) and (p.ysheet_view_name in sheet.views.Maps)): x = sheet.views.Maps[p.xsheet_view_name].last.data y = sheet.views.Maps[p.ysheet_view_name].last.data filename_suffix = "_" + sheet.name title = 'Topographic mapping to ' + sheet.name + ' at time ' \ + topo.sim.timestr() super(topographic_grid, self).__call__(x=x, y=y, title=title, filename_suffix=filename_suffix)
def __init__(self,inherent_features=[],**params): """ If a dataset already and inherently includes certain features, a list with the inherent feature names should be supplied. Any extra parameter values supplied here will be passed down to the feature_coordinators requested in features_to_vary. """ p=ParamOverrides(self,params,allow_extra_keywords=True) super(PatternCoordinator, self).__init__(**p.param_keywords()) self._feature_params = p.extra_keywords() self._inherent_features = inherent_features # TFALERT: Once spatial frequency (sf) is added, this will # cause warnings, because all image datasets will have a # spatial frequency inherent feature, but mostly we just # ignore that by having only a single size of DoG, which # discards all but a narrow range of sf. So the dataset will # have sf inherently, but that won't be an error or even # worthy of a warning. if(len(set(self._inherent_features) - set(self.features_to_vary))): self.warning('Inherent feature present which is not requested in features') self._feature_coordinators_to_apply = [] for feature, feature_coordinator in self.feature_coordinators.items(): if feature in self.features_to_vary and feature not in self._inherent_features: # if it is a list, append each list item individually if isinstance(feature_coordinator,list): for individual_feature_coordinator in feature_coordinator: self._feature_coordinators_to_apply.append(individual_feature_coordinator) else: self._feature_coordinators_to_apply.append(feature_coordinator)
def __call__(self,**params_to_override): p = ParamOverrides(self,params_to_override) if self.time_dependent: if 'name' in p: self._initialize_random_state(seed=self.seed, shared=True, name=p.name) self._hash_and_seed() shape = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape result = self._distrib(shape,p) self._apply_mask(p,result) for of in p.output_fns: of(result) return result
def __call__(self, viewcontainer, **params): p = ParamOverrides(self, params) objects = dict(topo.sim.objects(), **dict([(proj.name, proj) for proj in topo.sim.connections()])) for path, container in viewcontainer.path_items.items(): label, src_name = path source = objects[src_name] if isinstance(source, Sheet): storage = source.views[p.sublabel] if p.sublabel else source.views else: proj_store = source.dest.views[source.name] = {} proj_store[p.sublabel] = {} storage = proj_store[p.sublabel] if label not in storage or p.only_latest: storage[label] = container else: storage[label].update(container)
def __call__(self, data, cyclic_range=1.0, **params): p = ParamOverrides(self, params) r, c = data.shape dx = np.diff(data, 1, axis=1)[0:r - 1, 0:c - 1] dy = np.diff(data, 1, axis=0)[0:r - 1, 0:c - 1] if cyclic_range is not None: # Wrap into the specified range # Convert negative differences to an equivalent positive value dx = wrap(0, cyclic_range, dx) dy = wrap(0, cyclic_range, dy) # # Make it increase as gradient reaches the halfway point, # and decrease from there dx = 0.5 * cyclic_range - np.abs(dx - 0.5 * cyclic_range) dy = 0.5 * cyclic_range - np.abs(dy - 0.5 * cyclic_range) return super(gradientplot, self).__call__(np.sqrt(dx*dx + dy*dy), **p)
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self, params, allow_extra_keywords=True) err_msg = "%s must be enabled for motion" if not param.Dynamic.time_dependent: raise RuntimeError(err_msg % "param.Dynamic.time_dependent") if not numbergen.RandomDistribution.time_dependent: raise RuntimeError(err_msg % "numbergen.RandomDistribution.time_dependent") moved_pattern = Sweeper(generator=copy.deepcopy(pattern), speed=p.speed, reset_period=p.reset_period, time_fn=p.time_fn) return moved_pattern
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self,params,allow_extra_keywords=True) new_pattern=copy.copy(pattern) if(pattern_label.count('Left')): new_pattern.scale = (1-p.dim_fraction) + p.dim_fraction * \ (2.0-numbergen.UniformRandom(lbound=0, ubound=2, seed=master_seed+55+pattern_number, name="OcularityCoordinator"+str(pattern_number))) elif(pattern_label.count('Right')): new_pattern.scale = (1-p.dim_fraction) + p.dim_fraction * \ numbergen.UniformRandom(lbound=0, ubound=2, seed=master_seed+55+pattern_number, name="OcularityCoordinator"+str(pattern_number)) else: self.warning('Skipping region %s; Ocularity is defined only for Left and Right retinas.' % pattern) return new_pattern
def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): p = ParamOverrides(self,params,allow_extra_keywords=True) new_pattern=copy.copy(pattern) if(pattern_label.count('Left')): new_pattern.x = pattern.get_value_generator('x')-\ numbergen.UniformRandom(lbound=-p.disparity_bound, ubound=p.disparity_bound, seed=master_seed+45+pattern_number, name="DisparityCoordinator"+str(pattern_number)) elif(pattern_label.count('Right')): new_pattern.x = pattern.get_value_generator('x')+\ numbergen.UniformRandom(lbound=-p.disparity_bound, ubound=p.disparity_bound, seed=master_seed+45+pattern_number, name="DisparityCoordinator"+str(pattern_number)) else: self.warning('Skipping region %s; Disparity is defined only for Left and Right retinas.' % pattern) return new_pattern
def __call__(self,script_file,**params_to_override): p=ParamOverrides(self,params_to_override,allow_extra_keywords=True) import os import shutil # Construct simulation name, etc. scriptbase= re.sub('.ty$','',os.path.basename(script_file)) prefix = "" if p.timestamp==(0,0): prefix += time.strftime(p.name_time_format) else: prefix += time.strftime(p.name_time_format, p.timestamp) prefix += "_" + scriptbase + "_" + p.tag simname = prefix # Construct parameter-value portion of filename; should do more filtering # CBENHANCEMENT: should provide chance for user to specify a # function (i.e. make this a function, and have a parameter to # allow the function to be overridden). # And sort by name by default? Skip ones that aren't different # from default, or at least put them at the end? prefix += p.dirname_params_filter(p.extra_keywords()) # Set provided parameter values in main namespace from topo.misc.commandline import global_params global_params.set_in_context(**p.extra_keywords()) # Create output directories if not os.path.isdir(normalize_path(p['output_directory'])): try: os.mkdir(normalize_path(p['output_directory'])) except OSError: pass # Catches potential race condition (simultaneous run_batch runs) dirname = self._truncate(p,p.dirname_prefix+prefix) normalize_path.prefix = normalize_path(os.path.join(p['output_directory'],dirname)) if os.path.isdir(normalize_path.prefix): print "Batch run: Warning -- directory already exists!" print "Run aborted; wait one minute before trying again, or else rename existing directory: \n" + \ normalize_path.prefix sys.exit(-1) else: os.mkdir(normalize_path.prefix) print "Batch run output will be in " + normalize_path.prefix if p['vc_info']: _print_vc_info(simname+".diffs") hostinfo = "Host: " + " ".join(platform.uname()) topographicalocation = "Topographica: " + os.path.abspath(sys.argv[0]) topolocation = "topo package: " + os.path.abspath(topo.__file__) scriptlocation = "script: " + os.path.abspath(script_file) starttime=time.time() startnote = "Batch run started at %s." % time.strftime("%a %d %b %Y %H:%M:%S +0000", time.gmtime()) # store a re-runnable copy of the command used to start this batch run try: # pipes.quote is undocumented, so I'm not sure which # versions of python include it (I checked python 2.6 and # 2.7 on linux; they both have it). import pipes quotefn = pipes.quote except (ImportError,AttributeError): # command will need a human to insert quotes before it can be re-used quotefn = lambda x: x command_used_to_start = string.join([quotefn(arg) for arg in sys.argv]) # CBENHANCEMENT: would be nice to separately write out a # runnable script that does everything necessary to # re-generate results (applies diffs etc). # Shadow stdout to a .out file in the output directory, so that # print statements will go to both the file and to stdout. batch_output = open(normalize_path(simname+".out"),'w') batch_output.write(command_used_to_start+"\n") sys.stdout = MultiFile(batch_output,sys.stdout) print print hostinfo print topographicalocation print topolocation print scriptlocation print print startnote from topo.misc.commandline import auto_import_commands auto_import_commands() # Ensure that saved state includes all parameter values from topo.command import save_script_repr param.parameterized.script_repr_suppress_defaults=False # Save a copy of the script file for reference shutil.copy2(script_file, normalize_path.prefix) shutil.move(normalize_path(scriptbase+".ty"), normalize_path(simname+".ty")) # Default case: times is just a number that scales a standard list of times times=p['times'] if not isinstance(times,list): times=[t*times for t in [0,50,100,500,1000,2000,3000,4000,5000,10000]] # Run script in main error_count = 0 initial_warning_count = param.parameterized.warning_count try: execfile(script_file,__main__.__dict__) #global_params.context global_params.check_for_unused_names() if p.save_global_params: _save_parameters(p.extra_keywords(),simname+".global_params.pickle") print_sizes() topo.sim.name=simname # Run each segment, doing the analysis and saving the script state each time for run_to in times: topo.sim.run(run_to - topo.sim.time()) p['analysis_fn']() save_script_repr() elapsedtime=time.time()-starttime param.Parameterized(name="run_batch").message( "Elapsed real time %02d:%02d." % (int(elapsedtime/60),int(elapsedtime%60))) if p['snapshot']: save_snapshot() except: error_count+=1 import traceback traceback.print_exc(file=sys.stdout) sys.stderr.write("Warning -- Error detected: execution halted.\n") print "\nBatch run completed at %s." % time.strftime("%a %d %b %Y %H:%M:%S +0000", time.gmtime()) print "There were %d error(s) and %d warning(s)%s." % \ (error_count,(param.parameterized.warning_count-initial_warning_count), ((" (plus %d warning(s) prior to entering run_batch)"%initial_warning_count if initial_warning_count>0 else ""))) # restore stdout sys.stdout = sys.__stdout__ batch_output.close()
def __call__(self, sheet, mat=None, **params): p = ParamOverrides(self, params) if p.extent is None: p.extent = sheet.bounds.aarect().lbrt() if mat is None: mat = sheet.activity return super(activityplot, self).__call__(mat, **p)