def frames(self): self.current_phase = 0 while True: center = imagen.SineGrating( mask_shape=imagen.Disk(smoothing=0.0, size=self.center_radius * 2.0), orientation=self.center_orientation, frequency=self.spatial_frequency, phase=self.current_phase, bounds=BoundingBox(radius=self.size_x / 2.0), offset=0, scale=2 * self.background_luminance * self.contrast / 100.0, xdensity=self.density, ydensity=self.density)() r = (self.center_radius + self.surround_radius + self.gap) / 2.0 t = (self.surround_radius - self.center_radius - self.gap) / 2.0 surround = imagen.SineGrating( mask_shape=imagen.Ring(thickness=t * 2.0, smoothing=0.0, size=r * 2.0), orientation=self.surround_orientation, frequency=self.spatial_frequency, phase=self.current_phase, bounds=BoundingBox(radius=self.size_x / 2.0), offset=0, scale=2 * self.background_luminance * self.contrast / 100.0, xdensity=self.density, ydensity=self.density)() offset = imagen.Constant( mask_shape=imagen.Disk(smoothing=0.0, size=self.surround_radius * 2.0), bounds=BoundingBox(radius=self.size_x / 2.0), scale=self.background_luminance * (100.0 - self.contrast) / 100.0, xdensity=self.density, ydensity=self.density)() background = (imagen.Disk( smoothing=0.0, size=self.surround_radius * 2.0, bounds=BoundingBox(radius=self.size_x / 2.0), xdensity=self.density, ydensity=self.density)() - 1) * -self.background_luminance yield (numpy.add.reduce( [numpy.maximum(center, surround), offset, background]), [self.current_phase]) self.current_phase += 2 * pi * (self.frame_duration / 1000.0) * self.temporal_frequency
def frames(self): self.current_phase = 0 while True: a = imagen.SineGrating(orientation=self.orientation, frequency=self.spatial_frequency, phase=self.current_phase, bounds=BoundingBox(radius=self.size_x / 2), offset=self.background_luminance * (100.0 - self.contrast) / 100.0, scale=2 * self.background_luminance * self.contrast / 100.0, xdensity=self.density, ydensity=self.density)() b = imagen.Null(scale=self.background_luminance, bounds=BoundingBox(radius=self.size_x / 2), xdensity=self.density, ydensity=self.density)() c = imagen.Disk(smoothing=0.0, size=self.radius * 2, scale=1.0, bounds=BoundingBox(radius=self.size_x / 2), xdensity=self.density, ydensity=self.density)() d1 = numpy.multiply(a, c) d2 = numpy.multiply(b, -(c - 1.0)) d = numpy.add.reduce([d1, d2]) yield (d, [self.current_phase]) self.current_phase += 2 * pi * (self.frame_duration / 1000.0) * self.temporal_frequency
def V1_afferent(self, src_properties, dest_properties): params = super(ModelSCALSparse, self).V1_afferent(src_properties, dest_properties) # Adjust density for size of disk mask disk = ig.Disk(smoothing=0.0) output_fns = [CFPOF_DivisiveNormalizeL1_Sparse] if self.sprout_and_retract: cf_shape = disk same_shape = True output_fns = [ CFSPOF_SproutRetract(target_sparsity=self.afferent_density) ] + output_fns else: density = self.afferent_density * (1 / (np.pi / 4)) cf_shape = ig.random.BinaryUniformRandom(on_probability=min( [1, density]), mask_shape=disk, name='AffDensity') same_shape = False return dict(params[0], cf_shape=cf_shape, cf_type=SparseConnectionField, same_cf_shape_for_all_cfs=same_shape, response_fn=CFPRF_DotProduct_Sparse, learning_fn=CFPLF_Hebbian_Sparse, weights_output_fns=output_fns)
def __init__(self, name, source, target, strength, delay, radius, initial_connection_kernel): """ Each Projection has a source sheet and target sheet. Parameters ---------- radius : float How big the connections fields will be in the source sheet coordinates! source : Sheet The sheet from which projection passes rates. target : Sheet The sheet to which projection passes rates. strength : float The strength of the projection. inititial_connection_kernel: ndarray The initial connection kernel. """ Projection.__init__(self, name, source, target, strength, delay) self.radius = radius mask = imagen.Disk(xdensity=source.density, ydensity=source.density, bounds=BoundingBox(radius=source.size / 2), size=self.radius * 2, smoothing=0) initial_connection_kernel.xdensity = source.density initial_connection_kernel.ydensity = source.density initial_connection_kernel.bounds = BoundingBox(radius=source.size / 2.0) source_dim = self.source.unit_diameter target_dim = self.target.unit_diameter self.cfs = numpy.zeros( (target_dim * target_dim, source_dim * source_dim), dtype=numpy.float32) self.masks = numpy.zeros( (target_dim * target_dim, source_dim * source_dim), dtype=numpy.float32) for i in xrange(target_dim): for j in xrange(target_dim): ci, cj = self.target.index_to_coord(i, j) self.cfs[i * target_dim + j, :] = initial_connection_kernel( x=cj, y=-ci).flatten() self.masks[i * target_dim + j, :] = mask(x=cj, y=-ci).flatten() #apply masks and normalize self.cfs = numpy.multiply(self.cfs, self.masks) self.cfs = self.cfs / numpy.sum(numpy.abs(self.cfs), axis=1)[:, numpy.newaxis] assert numpy.min(self.masks) == 0 and numpy.max(self.masks) == 1 self.activity = numpy.zeros((target_dim, target_dim), dtype=numpy.float32)
def property_setup(self, properties): properties = super(ModelGCALInheritingColor, self).property_setup(properties) "Specify weight initialization, response function, and learning function" projection.CFProjection.cf_shape=imagen.Disk(smoothing=0.0) projection.CFProjection.response_fn=optimized.CFPRF_DotProduct_cython() projection.CFProjection.learning_fn=optimized.CFPLF_Hebbian_cython() projection.CFProjection.weights_output_fns=[transferfn.optimized.CFPOF_DivisiveNormalize_L1_cython()] projection.SharedWeightCFProjection.response_fn=responsefn.optimized.CFPRF_DotProduct_cython() return properties
def frames(self): self.current_phase = 0 while True: d = imagen.Disk(smoothing=0.0, size=self.radius * 2, offset=self.background_luminance, scale=self.background_luminance * (self.contrast / 100.0), bounds=BoundingBox(radius=self.size_x / 2), xdensity=self.density, ydensity=self.density)() yield (d, [self.current_phase])
def frames(self): fieldsize_x = self.size_x * self.density fieldsize_y = self.size_y * self.density folder_name = Global.root_directory + "/TextureImagesStimuli" libpath = __file__.replace( "/texture_based.py", "") + "/textureLib" #path to the image processing library matlabPyrToolspath = os.path.join(libpath, "textureSynth", "matlabPyrTools") if not os.path.isdir(matlabPyrToolspath): raise IOError( "matlabPyrTools should be downloaded from https://github.com/LabForComputationalVision/matlabPyrTools and its content should be put in the directory " + matlabPyrToolspath) octave.addpath(libpath) im = octave.textureBasedStimulus(self.texture_path, self.stats_type, self.seed, fieldsize_x, fieldsize_y, libpath) scale = 2. * self.background_luminance / (numpy.max(im) - numpy.min(im)) im = (im - numpy.min(im)) * scale if not os.path.exists(folder_name): os.mkdir(folder_name) assert (im.shape == (fieldsize_x, fieldsize_y) ), "Image dimensions do not correspond to visual field size" b = imagen.Constant(scale=self.background_luminance, bounds=BoundingBox(radius=self.size_x / 2), xdensity=self.density, ydensity=self.density)() c = imagen.Disk(smoothing=0.0, size=self.radius * 2, scale=1.0, bounds=BoundingBox(radius=self.size_x / 2), xdensity=self.density, ydensity=self.density)() d1 = numpy.multiply(im, c) d2 = numpy.multiply(b, -(c - 1.0)) d = numpy.add.reduce([d1, d2]) d = d.astype(numpy.uint8) IM = Image.fromarray(d) IM.save(folder_name + "/" + self.texture + "sample" + str(self.sample) + "type" + str(self.stats_type) + 'radius' + str(self.radius) + '.pgm') while True: yield (d, [0])
def setup_attributes(self, attrs): attrs = super(ModelGCAL, self).setup_attributes(attrs) "Specify weight initialization, response function, and learning function" projection.CFProjection.cf_shape = imagen.Disk(smoothing=0.0) projection.CFProjection.response_fn = responsefn.optimized.CFPRF_DotProduct_opt( ) projection.CFProjection.learning_fn = learningfn.optimized.CFPLF_Hebbian_opt( ) projection.CFProjection.weights_output_fns = [ transferfn.optimized.CFPOF_DivisiveNormalizeL1_opt() ] projection.SharedWeightCFProjection.response_fn = responsefn.optimized.CFPRF_DotProduct_opt( ) return attrs
def property_setup(self, properties): "Specify weight initialization, response function, and learning function" properties = super(ModelSCAL, self).property_setup(properties) projection.CFProjection.cf_shape = ig.Disk(smoothing=0.0) projection.CFProjection.response_fn = optimized.CFPRF_DotProduct_cython( ) projection.CFProjection.learning_fn = optimized.CFPLF_Hebbian_cython() projection.CFProjection.weights_output_fns = [ optimized.CFPOF_DivisiveNormalize_L1_cython() ] projection.SharedWeightCFProjection.response_fn = optimized.CFPRF_DotProduct_cython( ) sheet.SettlingCFSheet.joint_norm_fn = optimized.compute_joint_norm_totals_cython return properties
def V1_afferent(self, src_properties, dest_properties): "Projection delay and learning rate modified" paramlist = super(ModelTCAL, self).V1_afferent( src_properties, dest_properties) scatter = IdentityTF() # Default when distribution is None if self.lgn_scatter_distribution is not None: scale, offset = self._scatter_scale_offset() distribution = self.lgn_scatter_distribution( name='LGN Latency Scatter', offset=offset, scale=scale) scatter = TemporalScatter(timestep=self.timestep, span=self.lgn_scatter_span, distribution=distribution) return dict(paramlist, cf_shape = imagen.Disk(), same_cf_shape_for_all_cfs=True, input_fns=[scatter], delay = paramlist['delay']-(self.lgn_scatter_span/2.0))
def __call__(self, projection, **params): time = math.ceil(topo.sim.time()) if self.disk_mask: self.disk = ig.Disk(size=1.0,smoothing=0.0) # Get CF and src sheet shapes cf_x,cf_y = projection.dest.activity.shape src_x,src_y = projection.src.activity.shape # Initialize sparse triplet arrays y_array = np.zeros((src_x*src_y*cf_y),dtype=np.int32) x_array = np.zeros((src_x*src_y*cf_y),dtype=np.int32) val_array = np.zeros((src_x*src_y*cf_y),dtype=sparse_type) # Create new sparse matrix to accumulate into sum_sparse = sparse.csarray_float(projection.src.activity.shape,projection.dest.activity.shape) # Counters for logging sprout_sum = 0; prune_sum = 0; unit_total = 0 self.mask_total = 0 if (time == 0): if not hasattr(self,"initial_conns"): self.initial_conns = {} self.initial_conns[projection.name] = projection.n_conns() elif (time % self.interval) == 0: idx=0 for cidx,cf in enumerate(projection.flatcfs): temp_weights = cf.weights dense_unit_mask = (1.0 - (temp_weights>0.0)) dim1,dim2 = temp_weights.shape sprout_count,prune_idx,nnz = self.calc_ratios(temp_weights) self.prune(temp_weights,prune_idx) nnz_pp = np.count_nonzero(temp_weights) prune_sum += (nnz_pp-nnz) if sprout_count: self.sprout(temp_weights,dense_unit_mask,sprout_count) nnz_ps = np.count_nonzero(temp_weights) sprout_sum += nnz_ps - nnz_pp unit_total += nnz_ps # Populate sparse array chunk temp_sparse = sparse.csarray_float(projection.src.activity.shape,projection.dest.activity.shape) x1,x2,y1,y2 = cf.input_sheet_slice.tolist() for cnx in range(dim1): val_array[idx:idx+dim2] = temp_weights[cnx,:] x_val = (x1+cnx) * src_y + y1 x_array[idx:idx+dim2] = range(x_val,x_val+dim2) y_array[idx:idx+dim2] = cidx idx += dim2 # Populate combined sparse array with sparse array chunk if (cidx+1)%cf_y == 0: nnz_idx = val_array.nonzero() temp_sparse.setTriplets(x_array[nnz_idx],y_array[nnz_idx],val_array[nnz_idx]) sum_sparse += temp_sparse x_array *= 0; y_array *= 0; val_array *= 0.0 idx=0 projection.weights = sum_sparse del temp_sparse, sum_sparse projection.weights.compress()
ipython.magic("load_ext holoviews.ipython") ipython.magic("opts Layout [vertical_spacing=0.0 horizontal_spacing=0.0] Image [show_xaxis=None show_yaxis=None show_frame=False show_title=False padding=0]") def illusion(pat): h, w = 256, 256 uni = Image.new('RGB', (h,w)) for i in range(0, w, bw): for j in range(0, h, bh): uni.paste(pat, (i, j)) box = (50, 50, h-50, w-50) blur = uni.filter(ImageFilter.BLUR) blur = blur.crop(box) uni.paste(blur, box) return uni shapes = [ig.Rectangle(), ig.RawRectangle(), ig.Ring(), ig.Disk()] c = 0 for shape in shapes: for i in range(-0.95, 0.01, 0.95): for j in range(-0.95,0.01, 0.95): shape.x = i shape.y = j c += 1 hv.save(shape[:], 'illusion_image/blur/uniform/{}.png'.format(c)); pat = Image.open('illusion_image/blur/uniform/{}.png'.format(c)) pat = pat.resize((16,16)) pat.save('illusion_image/blur/uniform/{}.png'.format(c)) ill_0 = illusion(pat) ill_0.save('illusion_image/blur/blurred/{}.png'.format(c))