def setUp(self): self.op = FilterActs(module_stride=self.module_stride, openmp=False) self.op_omp = FilterActs(module_stride=self.module_stride, openmp=True) self.s_filters_list = [ theano.shared(rand(fshape, self.dtype)) for fshape in self.fshape_list ] self.s_images_list = [ theano.shared(rand(ishape, self.dtype)) for ishape in self.ishape_list ]
def alloc(cls, conf, image_shape, # input dimensionality filters_hs_shape, filters_irange, sigma, seed = 8923402, ): rng = numpy.random.RandomState(seed) self = cls() n_images, n_channels, n_img_rows, n_img_cols = image_shape n_filters_hs_modules, n_filters_hs_per_modules, fcolors, n_filters_hs_rows, n_filters_hs_cols = filters_hs_shape assert fcolors == n_channels self.sigma = sigma self.v_shape = image_shape print 'v_shape' print self.v_shape self.filters_hs_shape = filters_hs_shape print 'self.filters_hs_shape' print self.filters_hs_shape self.out_conv_hs_shape = FilterActs.infer_shape_without_instance(self.v_shape,self.filters_hs_shape) print 'self.out_conv_hs_shape' print self.out_conv_hs_shape conv_bias_hs_shape = (n_filters_hs_modules,n_filters_hs_per_modules) self.conv_bias_hs_shape = conv_bias_hs_shape print 'self.conv_bias_hs_shape' print self.conv_bias_hs_shape bias_v_shape = self.v_shape[1:] self.bias_v_shape = bias_v_shape print 'self.bias_v_shape' print self.bias_v_shape self.filters_hs = sharedX(rng.randn(*filters_hs_shape) * filters_irange , 'filters_hs') #conv_bias_ival = rng.rand(*conv_bias_hs_shape)*2-1 #conv_bias_ival *= conf['conv_bias_irange'] #conv_bias_ival += conf['conv_bias0'] conv_bias_ival = numpy.zeros(conv_bias_hs_shape) self.conv_bias_hs = sharedX(conv_bias_ival, name='conv_bias_hs') self.bias_v = sharedX(numpy.zeros(self.bias_v_shape), name='bias_v') negsample_mask = numpy.zeros((n_channels,n_img_rows,n_img_cols),dtype=floatX) negsample_mask[:,n_filters_hs_rows:n_img_rows-n_filters_hs_rows+1,n_filters_hs_cols:n_img_cols-n_filters_hs_cols+1] = 1 self.negsample_mask = sharedX(negsample_mask,'negsample_mask') self.conf = conf self._params = [self.filters_hs, self.conv_bias_hs, self.bias_v ] return self
def setUp(self): self.op = FilterActs(self.module_stride) for i in range(self.nbTests): self.s_images_list = [ theano.shared(rand(ishape, self.dtype)) for ishape in self.ishape_list ] self.s_filters_list = [ theano.shared(rand(fshape, self.dtype)) for fshape in self.fshape_list ]
def alloc(cls, conf, image_shape, # input dimensionality filters_hs_shape, filters_irange, v_prec, v_prec_lower_limit, #should be parameter of the training algo seed = 8923402 ): print 'alloc rbm' rng = numpy.random.RandomState(seed) self = cls() n_images, n_channels, n_img_rows, n_img_cols = image_shape n_filters_hs_modules, n_filters_hs_per_modules, fcolors, n_filters_hs_rows, n_filters_hs_cols = filters_hs_shape assert fcolors == n_channels self.v_shape = image_shape print 'v_shape' print self.v_shape self.filters_hs_shape = filters_hs_shape print 'self.filters_hs_shape' print self.filters_hs_shape self.out_conv_hs_shape = FilterActs.infer_shape_without_instance(self.v_shape,self.filters_hs_shape) print 'self.out_conv_hs_shape' print self.out_conv_hs_shape conv_bias_hs_shape = self.out_conv_hs_shape[1:] #conv_bias_hs_shape = (n_filters_hs_modules, n_filters_hs_per_modules) self.conv_bias_hs_shape = conv_bias_hs_shape print 'self.conv_bias_hs_shape' print self.conv_bias_hs_shape self.v_prec = sharedX(numpy.zeros((n_channels, n_img_rows, n_img_cols))+v_prec, 'var_v_prec') self.v_prec_fast = sharedX(numpy.zeros((n_channels, n_img_rows, n_img_cols))+conf['v_prec_lower_limit'], 'var_v_prec_fast') #self.v_prec = sharedX(v_prec, 'var_v_prec') #self.v_prec_fast = sharedX(0.0, 'var_v_prec_fast') self.v_prec_lower_limit = sharedX(v_prec_lower_limit, 'v_prec_lower_limit') self.v_prec_fast_lower_limit = sharedX(conf['v_prec_fast_lower_limit'], 'v_prec_fast_lower_limit') self.filters_hs = sharedX(rng.randn(*filters_hs_shape) * filters_irange , 'filters_hs') self.filters_hs_fast = sharedX(numpy.zeros(filters_hs_shape), 'filters_hs_fast') self.conv_bias_hs = sharedX(numpy.zeros(self.conv_bias_hs_shape), name='conv_bias_hs') self.conv_bias_hs_fast = sharedX(numpy.zeros(self.conv_bias_hs_shape), name='conv_bias_hs_fast') conv_mu_ival = numpy.zeros(conv_bias_hs_shape,dtype=floatX) + conf['conv_mu0'] self.conv_mu = sharedX(conv_mu_ival, name='conv_mu') self.conv_mu_fast = sharedX(numpy.zeros(conv_bias_hs_shape,dtype=floatX), name='conv_mu_fast') if conf['alpha_logdomain']: conv_alpha_ival = numpy.zeros(conv_bias_hs_shape,dtype=floatX) + numpy.log(conf['conv_alpha0']) self.conv_alpha = sharedX(conv_alpha_ival,'conv_alpha') conv_alpha_ival_fast = numpy.zeros(conv_bias_hs_shape,dtype=floatX) #conv_alpha_ival_fast = numpy.zeros(conv_bias_hs_shape,dtype=floatX) + numpy.log(conf['alpha_min']) self.conv_alpha_fast = sharedX(conv_alpha_ival_fast, name='conv_alpha_fast') else: self.conv_alpha = sharedX( numpy.zeros(conv_bias_hs_shape)+conf['conv_alpha0'], 'conv_alpha') self.conv_alpha_fast = sharedX( numpy.zeros(conv_bias_hs_shape), name='conv_alpha_fast') #self.conv_alpha_fast = sharedX( # numpy.zeros(conv_bias_hs_shape)+conf['alpha_min'], name='conv_alpha_fast') if conf['lambda_logdomain']: self.conv_lambda = sharedX( numpy.zeros(self.filters_hs_shape) + numpy.log(conf['lambda0']), name='conv_lambda') self.conv_lambda_fast = sharedX( numpy.zeros(self.filters_hs_shape), name='conv_lambda_fast') #self.conv_lambda_fast = sharedX( # numpy.zeros(self.filters_hs_shape) # + numpy.log(conf['lambda_min']), # name='conv_lambda_fast') else: self.conv_lambda = sharedX( numpy.zeros(self.filters_hs_shape) + (conf['lambda0']), name='conv_lambda') self.conv_lambda_fast = sharedX( numpy.zeros(self.filters_hs_shape), name='conv_lambda_fast') #self.conv_lambda_fast = sharedX( # numpy.zeros(self.filters_hs_shape) # + (conf['lambda_min']), # name='conv_lambda_fast') negsample_mask = numpy.zeros((n_channels,n_img_rows,n_img_cols),dtype=floatX) negsample_mask[:,n_filters_hs_rows:n_img_rows-n_filters_hs_rows+1,n_filters_hs_cols:n_img_cols-n_filters_hs_cols+1] = 1 self.negsample_mask = sharedX(negsample_mask,'negsample_mask') self.conf = conf self._params = [self.v_prec, self.filters_hs, self.conv_bias_hs, self.conv_mu, self.conv_alpha, self.conv_lambda ] self._params_fast = [self.v_prec_fast, self.filters_hs_fast, self.conv_bias_hs_fast, self.conv_mu_fast, self.conv_alpha_fast, self.conv_lambda_fast ] return self
def Toncv(image,filters,module_stride=1): op = FilterActs(module_stride) return op(image,filters)
def test_op_eq(self): assert FilterActs(1) == FilterActs(1) assert not (FilterActs(1) != FilterActs(1)) assert (FilterActs(2) != FilterActs(1)) assert FilterActs(1) != None
def alloc(cls, conf, image_shape, # input dimensionality filters_hs_shape, filters_irange, v_prec, v_prec_lower_limit, #should be parameter of the training algo seed = 8923402 ): print 'alloc rbm' rng = numpy.random.RandomState(seed) self = cls() n_images, n_channels, n_img_rows, n_img_cols = image_shape n_filters_hs_modules, n_filters_hs_per_modules, fcolors, n_filters_hs_rows, n_filters_hs_cols = filters_hs_shape assert fcolors == n_channels self.v_shape = image_shape print 'v_shape' print self.v_shape self.filters_hs_shape = filters_hs_shape print 'self.filters_hs_shape' print self.filters_hs_shape self.out_conv_hs_shape = FilterActs.infer_shape_without_instance(self.v_shape,self.filters_hs_shape) print 'self.out_conv_hs_shape' print self.out_conv_hs_shape #conv_bias_hs_shape = self.out_conv_hs_shape[1:] conv_bias_hs_shape = (n_filters_hs_modules, n_filters_hs_per_modules) self.conv_bias_hs_shape = conv_bias_hs_shape print 'self.conv_bias_hs_shape' print self.conv_bias_hs_shape self.v_prec = sharedX(numpy.zeros((n_channels, n_img_rows, n_img_cols))+v_prec, 'var_v_prec') self.v_prec_lower_limit = sharedX(v_prec_lower_limit, 'v_prec_lower_limit') #a = self.v_prec.broadcastable #b = self.v_prec_lower_limit.broadcastable #print a,b self.filters_hs = sharedX(rng.randn(*filters_hs_shape) * filters_irange , 'filters_hs') #a = self.filters_hs.broadcastable #print a #conv_bias_ival = rng.rand(*conv_bias_hs_shape)*2-1 #conv_bias_ival *= conf['conv_bias_irange'] #conv_bias_ival += conf['conv_bias0'] #self.conv_bias_hs = sharedX(conv_bias_ival, name='conv_bias_hs') self.conv_bias_hs = sharedX(numpy.zeros(self.conv_bias_hs_shape), name='conv_bias_hs') conv_mu_ival = numpy.zeros(conv_bias_hs_shape,dtype=floatX) + conf['conv_mu0'] self.conv_mu = sharedX(conv_mu_ival, 'conv_mu') if conf['alpha_logdomain']: conv_alpha_ival = numpy.zeros(conv_bias_hs_shape,dtype=floatX) + numpy.log(conf['conv_alpha0']) self.conv_alpha = sharedX(conv_alpha_ival,'conv_alpha') else: self.conv_alpha = sharedX( numpy.zeros(conv_bias_hs_shape)+conf['conv_alpha0'], 'conv_alpha') if conf['lambda_logdomain']: self.conv_lambda = sharedX( numpy.zeros(self.filters_hs_shape) + numpy.log(conf['lambda0']), name='conv_lambda') else: self.conv_lambda = sharedX( numpy.zeros(self.filters_hs_shape) + (conf['lambda0']), name='conv_lambda') negsample_mask = numpy.zeros((n_channels,n_img_rows,n_img_cols),dtype=floatX) negsample_mask[:,n_filters_hs_rows:n_img_rows-n_filters_hs_rows+1,n_filters_hs_cols:n_img_cols-n_filters_hs_cols+1] = 1 self.negsample_mask = sharedX(negsample_mask,'negsample_mask') self.conf = conf self._params = [self.v_prec, self.filters_hs, self.conv_bias_hs, self.conv_mu, self.conv_alpha, self.conv_lambda ] return self
def main_sample(filename, algo='Gibbs', rng=777888, burn_in=50001, save_interval=5000, n_files=10, sampling_for_v=False): rbm = cPickle.load(open(filename)) n_samples = 128 rbm.v_shape = (n_samples,1,120,120) rbm.out_conv_hs_shape = FilterActs.infer_shape_without_instance(rbm.v_shape,rbm.filters_hs_shape) rbm.v_prec = sharedX(numpy.zeros(rbm.v_shape[1:])+rbm.v_prec.get_value(borrow=True).mean(), 'var_v_prec') if algo == 'Gibbs': sampler = Gibbs.alloc(rbm, rng) new_particles = rbm.gibbs_step_for_v( sampler.particles, sampler.s_rng, border_mask=False, sampling_for_v=sampling_for_v, With_fast=False) new_particles = tensor.clip(new_particles, rbm.conf['particles_min'], rbm.conf['particles_max']) fn = theano.function([], [], updates={sampler.particles: new_particles}) particles = sampler.particles elif algo == 'HMC': print "WARNING THIS PROBABLY DOESNT WORK" # still need to figure out how to get the clipping into # the iterations of mcmc sampler = HMC(rbm, rbm.conf['batchsize'], rng) ups = sampler.updates() ups[sampler.positions] = tensor.clip(ups[sampler.positions], rbm.conf['particles_min'], rbm.conf['particles_max']) fn = theano.function([], [], updates=ups) particles = sampler.positions B_texture = Brodatz('../../../Brodatz/D6.gif', patch_shape=(1,98,98), noise_concelling=0.0, seed=3322 ,batchdata_size=1, rescale=1.0, rescale_size=2) shp = B_texture.test_img.shape img = numpy.zeros((1,)+shp) temp_img = numpy.asarray(B_texture.test_img, dtype='uint8') img[0,] = temp_img Image.fromarray(temp_img,'L').save('test_img.png') for i in xrange(burn_in): if i% 100 ==0: print i #savename = '%s_Large_sample_burn_%04i.png'%(filename,i) #tmp = particles.get_value(borrow=True)[0,0,11:363,11:363] #w = numpy.asarray(255 * (tmp - tmp.min()) / (tmp.max() - tmp.min() + 1e-6), dtype='uint8') #Image.fromarray(w,'L').save(savename) savename = '%s_sample_burn_%04i.png'%(filename,i) if i % 1000 == 0 and i!=0: print 'saving' Image.fromarray( tile_conv_weights( particles.get_value(borrow=True)[:,:,11:110,11:110], flip=False,scale_each=True), 'L').save(savename) samples = particles.get_value(borrow=True)[:,:,11:110,11:110] for samples_index in xrange(n_samples): temp_samples = samples[samples_index,] #temp_samples = numpy.asarray(255 * (temp_samples - temp_samples.min()) / \ # (temp_samples.max() - temp_samples.min() + 1e-6), dtype='uint8') samples[samples_index,]= temp_samples CC = CrossCorrelation(img,samples, window_size=19, n_patches_of_samples=1) aaa = CC.TSS() print aaa.mean(),aaa.std() fn() """
def testMainOpSpeed(self): def do_time(output, mode=theano.Mode(linker='c')): f = theano.function([], output, mode=mode) t0 = time.time() [f() for i in range(self.n_calls)] t1 = time.time() return t1 - t0 for i in range(self.nbTests): print "image shape", self.ishape_list[i] print "filter shape", self.fshape_list[i] # Generate theano functions to run the op in python and in C output = self.op(self.s_images_list[i], self.s_filters_list[i]) output_omp = self.op_omp(self.s_images_list[i], self.s_filters_list[i]) output_fcols = FilterActs( module_stride=self.module_stride, openmp=False, fcols=self.fshape_list[i][-1])(self.s_images_list[i], self.s_filters_list[i]) output_fcols_omp = FilterActs( module_stride=self.module_stride, openmp=True, fcols=self.fshape_list[i][-1])(self.s_images_list[i], self.s_filters_list[i]) output_frows_fcols = FilterActs( module_stride=self.module_stride, openmp=False, fcols=self.fshape_list[i][-1], frows=self.fshape_list[i][-2])(self.s_images_list[i], self.s_filters_list[i]) output_frows_fcols_omp = FilterActs( module_stride=self.module_stride, openmp=True, fcols=self.fshape_list[i][-1], frows=self.fshape_list[i][-2])(self.s_images_list[i], self.s_filters_list[i]) # Run the OP in python py_t = do_time(output, mode=theano.Mode(linker='py')) print "py", py_t # Run the OP in C c_t = do_time(output, mode=theano.Mode(linker='c|py')) print "c|py", c_t, "speed up", py_t / c_t # Run the OP in C with fcols c_t_fcols = do_time(output_fcols) print "c fcols", c_t_fcols, "speed up", py_t / c_t_fcols # Run the OP in C with fcols, frows c_t_frows_fcols = do_time(output_frows_fcols) print "c frows_fcols", c_t_frows_fcols, "speed up", py_t / c_t_frows_fcols # Run the Op in C with openmp if theano.config.openmp: c_omp_t = do_time(output_omp) print "omp c", c_omp_t, "speed up python", py_t / c_omp_t, "speed up c", c_t / c_omp_t c_omp_fcols_t = do_time(output_fcols_omp) print "omp c fcols", c_omp_fcols_t, "speed up python", py_t / c_omp_fcols_t, "speed up c fcols", c_t_fcols / c_omp_fcols_t c_omp_frows_fcols_t = do_time(output_frows_fcols_omp) print "omp c fcols", c_omp_frows_fcols_t, "speed up python", py_t / c_omp_frows_fcols_t, "speed up c frows_fcols", c_t_frows_fcols / c_omp_frows_fcols_t