def _transform_zca(self, x, fit=False): if self._to_zca: if fit: self._zca_class = preprocessing.ZCA(store_inverse=True) self._zca_class.fit(x) x = self._zca_class.transform(x) return x
def main(): data_dir = string.preprocess('${PYLEARN2_DATA_PATH}/stl10') print('Loading STL10-10 unlabeled and train datasets...') downsampled_dir = data_dir + '/stl10_32x32' data = serial.load(downsampled_dir + '/unlabeled.pkl') supplement = serial.load(downsampled_dir + '/train.pkl') print('Concatenating datasets...') data.set_design_matrix(np.concatenate((data.X, supplement.X), axis=0)) del supplement print("Preparing output directory...") patch_dir = data_dir + '/stl10_patches_8x8' serial.mkdir(patch_dir) README = open(patch_dir + '/README', 'w') README.write(textwrap.dedent(""" The .pkl files in this directory may be opened in python using cPickle, pickle, or pylearn2.serial.load. data.pkl contains a pylearn2 Dataset object defining an unlabeled dataset of 2 million 6x6 approximately whitened, contrast-normalized patches drawn uniformly at random from a downsampled (to 32x32) version of the STL-10 train and unlabeled datasets. preprocessor.pkl contains a pylearn2 Pipeline object that was used to extract the patches and approximately whiten / contrast normalize them. This object is necessary when extracting features for supervised learning or test set classification, because the extracted features must be computed using inputs that have been whitened with the ZCA matrix learned and stored by this Pipeline. They were created with the pylearn2 script make_stl10_patches.py. All other files in this directory, including this README, were created by the same script and are necessary for the other files to function correctly. """)) README.close() print("Preprocessing the data...") pipeline = preprocessing.Pipeline() pipeline.items.append(preprocessing.ExtractPatches(patch_shape=(8, 8), num_patches=2*1000*1000)) pipeline.items.append( preprocessing.GlobalContrastNormalization(sqrt_bias=10., use_std=True)) pipeline.items.append(preprocessing.ZCA()) data.apply_preprocessor(preprocessor=pipeline, can_fit=True) data.use_design_loc(patch_dir + '/data.npy') serial.save(patch_dir + '/data.pkl', data) serial.save(patch_dir + '/preprocessor.pkl', pipeline)
def main(): data_dir = string_utils.preprocess('${PYLEARN2_DATA_PATH}/cifar100') print('Loading CIFAR-100 train dataset...') train = CIFAR100(which_set='train', gcn=55.) print("Preparing output directory...") output_dir = data_dir + '/pylearn2_gcn_whitened' serial.mkdir(output_dir) README = open(output_dir + '/README', 'w') README.write( textwrap.dedent(""" The .pkl files in this directory may be opened in python using cPickle, pickle, or pylearn2.serial.load. train.pkl, and test.pkl each contain a pylearn2 Dataset object defining a labeled dataset of a 32x32 contrast normalized, approximately whitened version of the CIFAR-100 dataset. train.pkl contains labeled train examples. test.pkl contains labeled test examples. preprocessor.pkl contains a pylearn2 ZCA object that was used to approximately whiten the images. You may want to use this object later to preprocess other images. They were created with the pylearn2 script make_cifar100_gcn_whitened.py. All other files in this directory, including this README, were created by the same script and are necessary for the other files to function correctly. """)) README.close() print("Learning the preprocessor \ and preprocessing the unsupervised train data...") preprocessor = preprocessing.ZCA() train.apply_preprocessor(preprocessor=preprocessor, can_fit=True) print('Saving the training data') train.use_design_loc(output_dir + '/train.npy') serial.save(output_dir + '/train.pkl', train) print("Loading the test data") test = CIFAR100(which_set='test', gcn=55.) print("Preprocessing the test data") test.apply_preprocessor(preprocessor=preprocessor, can_fit=False) print("Saving the test data") test.use_design_loc(output_dir + '/test.npy') serial.save(output_dir + '/test.pkl', test) serial.save(output_dir + '/preprocessor.pkl', preprocessor)
def main(): data_dir = string_utils.preprocess('${PYLEARN2_DATA_PATH}') print('Loading CIFAR-100 train dataset...') data = CIFAR100(which_set='train') print("Preparing output directory...") patch_dir = data_dir + '/cifar100/cifar100_patches' serial.mkdir(patch_dir) README = open(patch_dir + '/README', 'w') README.write( textwrap.dedent(""" The .pkl files in this directory may be opened in python using cPickle, pickle, or pylearn2.serial.load. data.pkl contains a pylearn2 Dataset object defining an unlabeled dataset of 2 million 6x6 approximately whitened, contrast-normalized patches drawn uniformly at random from the CIFAR-100 train set. preprocessor.pkl contains a pylearn2 Pipeline object that was used to extract the patches and approximately whiten / contrast normalize them. This object is necessary when extracting features for supervised learning or test set classification, because the extracted features must be computed using inputs that have been whitened with the ZCA matrix learned and stored by this Pipeline. They were created with the pylearn2 script make_cifar100_patches.py. All other files in this directory, including this README, were created by the same script and are necessary for the other files to function correctly. """)) README.close() print("Preprocessing the data...") pipeline = preprocessing.Pipeline() pipeline.items.append( preprocessing.ExtractPatches(patch_shape=(6, 6), num_patches=2 * 1000 * 1000)) pipeline.items.append( preprocessing.GlobalContrastNormalization(sqrt_bias=10., use_std=True)) pipeline.items.append(preprocessing.ZCA()) data.apply_preprocessor(preprocessor=pipeline, can_fit=True) data.use_design_loc(patch_dir + '/data.npy') serial.save(patch_dir + '/data.pkl', data) serial.save(patch_dir + '/preprocessor.pkl', pipeline)
def get_preprocess_zca(self, preprocess_id): row = self.db.executeSQL( """ SELECT n_components, n_drop_components, filter_bias FROM hps3.preprocess_zca WHERE preprocess_id = %s """, (preprocess_id, ), self.db.FETCH_ONE) if not row or row is None: raise HPSData("No zca preprocess for preprocess_id="\ +str(preprocess_id)) (n_components, n_drop_components, filter_bias) = row return pp.ZCA(n_components=n_components, filter_bias=filter_bias, n_drop_components=n_drop_components)
def get_dataset_cifar10(): """ The orginal pipeline on cifar10 from pylearn2. Please refer to pylearn2/scripts/train_example/make_dataset.py for details. """ train_path = 'cifar10_preprocessed_train.pkl' test_path = 'cifar10_preprocessed_test.pkl' if os.path.exists(train_path) and \ os.path.exists(test_path): print 'loading preprocessed data' trainset = serial.load(train_path) testset = serial.load(test_path) else: print 'loading raw data...' trainset = cifar10.CIFAR10(w5B5B5B5Bhich_set="train") testset = cifar10.CIFAR10(which_set="test") print 'preprocessing data...' pipeline = preprocessing.Pipeline() pipeline.items.append( preprocessing.ExtractPatches(patch_shape=(8, 8), num_patches=150000)) pipeline.items.append(preprocessing.GlobalContrastNormalization()) pipeline.items.append(preprocessing.ZCA()) trainset.apply_preprocessor(preprocessor=pipeline, can_fit=True) trainset.use_design_loc('train_design.npy') testset.apply_preprocessor(preprocessor=pipeline, can_fit=True) testset.use_design_loc('test_design.npy') print 'saving preprocessed data...' serial.save('cifar10_preprocessed_train.pkl', trainset) serial.save('cifar10_preprocessed_test.pkl', testset) trainset.yaml_src = '!pkl: "%s"' % train_path testset.yaml_src = '!pkl: "%s"' % test_path # this path will be used for visualizing weights after training is done #global YAML return trainset, testset
def generate_patches(): datasets = OrderedDict() datasets['train'] = GenderWrite.gwdata.GWData(which_set='train', start=1, stop=201) datasets['valid'] = GenderWrite.gwdata.GWData(which_set='train', start=201, stop=283) datasets['test'] = GenderWrite.gwdata.GWData(which_set='test') datasets['tottrain'] = GenderWrite.gwdata.GWData(which_set='train') # preprocess patches pipeline = preprocessing.Pipeline() pipeline.items.append(preprocessing.GlobalContrastNormalization()) pipeline.items.append(preprocessing.ZCA()) for dstr, dset in datasets.iteritems(): print dstr # only fit on train data trainbool = dstr == 'train' or dstr == 'tottrain' dset.apply_preprocessor(preprocessor=pipeline, can_fit=trainbool) # save dset.use_design_loc(DATA_DIR + dstr + '_design.npy') serial.save(DATA_DIR + 'gw_preprocessed_' + dstr + '.pkl', dset)
preprocessor.pkl contains a pylearn2 ZCA object that was used to approximately whiten the images. You may want to use this object later to preprocess other images. They were created with the pylearn2 script make_cifar100_gcn_whitened.py. All other files in this directory, including this README, were created by the same script and are necessary for the other files to function correctly. """) README.close() print "Learning the preprocessor and preprocessing the unsupervised train data..." preprocessor = preprocessing.ZCA() train.apply_preprocessor(preprocessor = preprocessor, can_fit = True) print 'Saving the unsupervised data' train.use_design_loc(output_dir+'/train.npy') serial.save(output_dir + '/train.pkl', train) print "Loading the test data" test = CIFAR100(which_set = 'test', gcn = 55.) print "Preprocessing the test data" test.apply_preprocessor(preprocessor = preprocessor, can_fit = False) print "Saving the test data" test.use_design_loc(output_dir+'/test.npy') serial.save(output_dir+'/test.pkl', test)
to extract the patches and approximately whiten / contrast normalize them. This object is necessary when extracting features for supervised learning or test set classification, because the extracted features must be computed using inputs that have been whitened with the ZCA matrix learned and stored by this Pipeline. They were created with the pylearn2 script make_cifar100_patches.py. All other files in this directory, including this README, were created by the same script and are necessary for the other files to function correctly. """) README.close() print("Preprocessing the data...") pipeline = preprocessing.Pipeline() pipeline.items.append( preprocessing.ExtractPatches(patch_shape=(8, 8), num_patches=2 * 1000 * 1000)) pipeline.items.append( preprocessing.GlobalContrastNormalization(sqrt_bias=10., use_std=True)) pipeline.items.append(preprocessing.ZCA()) data.apply_preprocessor(preprocessor=pipeline, can_fit=True) data.use_design_loc(patch_dir + '/data.npy') serial.save(patch_dir + '/data.pkl', data) serial.save(patch_dir + '/preprocessor.pkl', pipeline)
def main(): data_dir = string.preprocess('${PYLEARN2_DATA_PATH}/stl10') print('Loading STL-10 unlabeled and train datasets...') downsampled_dir = data_dir + '/stl10_32x32' data = serial.load(downsampled_dir + '/unlabeled.pkl') supplement = serial.load(downsampled_dir + '/train.pkl') print('Concatenating datasets...') data.set_design_matrix(np.concatenate((data.X, supplement.X), axis=0)) print("Preparing output directory...") output_dir = data_dir + '/stl10_32x32_whitened' serial.mkdir(output_dir) README = open(output_dir + '/README', 'w') README.write( textwrap.dedent(""" The .pkl files in this directory may be opened in python using cPickle, pickle, or pylearn2.serial.load. unsupervised.pkl, unlabeled.pkl, train.pkl, and test.pkl each contain a pylearn2 Dataset object defining an unlabeled dataset of a 32x32 approximately whitened version of the STL-10 dataset. unlabeled.pkl contains unlabeled train examples. train.pkl contains labeled train examples. unsupervised.pkl contains the union of these (without any labels). test.pkl contains the labeled test examples. preprocessor.pkl contains a pylearn2 ZCA object that was used to approximately whiten the images. You may want to use this object later to preprocess other images. They were created with the pylearn2 script make_stl10_whitened.py. All other files in this directory, including this README, were created by the same script and are necessary for the other files to function correctly. """)) README.close() print("Learning the preprocessor \ and preprocessing the unsupervised train data...") preprocessor = preprocessing.ZCA() data.apply_preprocessor(preprocessor=preprocessor, can_fit=True) print('Saving the unsupervised data') data.use_design_loc(output_dir + '/unsupervised.npy') serial.save(output_dir + '/unsupervised.pkl', data) X = data.X unlabeled = X[0:100 * 1000, :] labeled = X[100 * 1000:, :] del X print("Saving the unlabeled data") data.X = unlabeled data.use_design_loc(output_dir + '/unlabeled.npy') serial.save(output_dir + '/unlabeled.pkl', data) del data del unlabeled print("Saving the labeled train data") supplement.X = labeled supplement.use_design_loc(output_dir + '/train.npy') serial.save(output_dir + '/train.pkl', supplement) del supplement del labeled print("Loading the test data") test = serial.load(downsampled_dir + '/test.pkl') print("Preprocessing the test data") test.apply_preprocessor(preprocessor=preprocessor, can_fit=False) print("Saving the test data") test.use_design_loc(output_dir + '/test.npy') serial.save(output_dir + '/test.pkl', test) serial.save(output_dir + '/preprocessor.pkl', preprocessor)
def get_dataset(tot=False, preprocessor='normal'): if not os.path.exists(DATA_DIR+'train.npy') or \ not os.path.exists(DATA_DIR+'test.npy') or \ not os.path.exists(DATA_DIR+'targets.npy'): initial_read() train_path = DATA_DIR+'train_'+preprocessor+'_preprocessed.pkl' valid_path = DATA_DIR+'valid_'+preprocessor+'_preprocessed.pkl' tottrain_path = DATA_DIR+'tottrain_'+preprocessor+'_preprocessed.pkl' test_path = DATA_DIR+'test_'+preprocessor+'_preprocessed.pkl' if os.path.exists(train_path) and os.path.exists(valid_path) and os.path.exists(test_path): print 'loading preprocessed data' trainset = serial.load(train_path) validset = serial.load(valid_path) if tot: tottrainset = serial.load(tottrain_path) testset = serial.load(test_path) else: print 'loading raw data...' trainset = Digits(which_set='train', start=0, stop=34000) validset = Digits(which_set='train', start=34000, stop=42000) tottrainset = Digits(which_set='train') testset = Digits(which_set='test') print 'preprocessing data...' pipeline = preprocessing.Pipeline() pipeline.items.append(preprocessing.GlobalContrastNormalization(sqrt_bias=10., use_std=True)) if preprocessor != 'nozca': # ZCA = zero-phase component analysis # very similar to PCA, but preserves the look of the original image better pipeline.items.append(preprocessing.ZCA()) # note the can_fit=False's: no sharing between train and valid data trainset.apply_preprocessor(preprocessor=pipeline, can_fit=True) validset.apply_preprocessor(preprocessor=pipeline, can_fit=False) tottrainset.apply_preprocessor(preprocessor=pipeline, can_fit=True) testset.apply_preprocessor(preprocessor=pipeline, can_fit=False) if preprocessor not in ('normal','nozca'): for data in (trainset, validset, tottrainset, testset): for ii in range(data.X.shape[0]): # normalize to [0,1] dmax = np.max(data.X[ii,:]) dmin = np.min(data.X[ii,:]) dnorm = (data.X[ii,:] - dmin) / (dmax - dmin) # and convert to PIL image img = Image.fromarray(dnorm.reshape(28, 28) * 255.).convert('L') # apply preprocessor if preprocessor == 'rotate': rot = rng.randint(-40, 41) img = img.rotate(rot, Image.BILINEAR) elif preprocessor == 'emboss': img = emboss(img) elif preprocessor == 'hshear': # coef = 0 means unsheared coef = -1 + np.random.rand()*2 # note: image is moved with (coef/2)*28 to center it after shearing img = img.transform((28,28), Image.AFFINE, (1,coef,-(coef/2)*28,0,1,0), Image.BILINEAR) elif preprocessor == 'vshear': coef = -1 + np.random.rand()*2 img = img.transform((28,28), Image.AFFINE, (1,0,0,coef,1,-(coef/2)*28), Image.BILINEAR) elif preprocessor == 'patch': # negative values are not possible in PIL, so do a zoom only transform then x1 = np.random.randint(0, 5) y1 = np.random.randint(0, 5) x2 = np.random.randint(0, 5) y2 = np.random.randint(0, 5) img = img.transform((28,28), Image.EXTENT, (x1, y1, 28-x2, 28-y2), Image.BILINEAR) # convert back to numpy array data.X[ii,:] = np.array(img.getdata()) / 255. if preprocessor == 'noisy': # add noise data.X[ii,:] += np.random.randn(28*28) * 0.1 # bound between [0,1] data.X[ii,:] = np.minimum(np.ones(28*28), np.maximum(np.zeros(28*28), data.X[ii,:])) # this uses numpy format for storage instead of pickle, for memory reasons trainset.use_design_loc(DATA_DIR+'train_'+preprocessor+'_design.npy') validset.use_design_loc(DATA_DIR+'valid_'+preprocessor+'_design.npy') tottrainset.use_design_loc(DATA_DIR+'tottrain_'+preprocessor+'_design.npy') testset.use_design_loc(DATA_DIR+'test_'+preprocessor+'_design.npy') # this path can be used for visualizing weights after training is done trainset.yaml_src = '!pkl: "%s"' % train_path validset.yaml_src = '!pkl: "%s"' % valid_path tottrainset.yaml_src = '!pkl: "%s"' % tottrain_path testset.yaml_src = '!pkl: "%s"' % test_path print 'saving preprocessed data...' serial.save(train_path, trainset) serial.save(valid_path, validset) serial.save(tottrain_path, tottrainset) serial.save(test_path, testset) if tot: return tottrainset, validset, testset else: return trainset, validset, testset
def get_data(tot=True, flatgrey=False): tottrain_path = DATA_DIR+'gz_preprocessed_tottrain' + str(SUBMODEL) + '_64x.pkl' test_path = DATA_DIR+'gz_preprocessed_test' + str(SUBMODEL) + '_64x.pkl' if os.path.exists(test_path): print 'loading preprocessed data' datasets = OrderedDict() # datasets['train'] = serial.load(train_path) # datasets['valid'] = serial.load(valid_path) if tot: datasets['tottrain'] = serial.load(tottrain_path) datasets['test'] = serial.load(test_path) if tot: return datasets['tottrain'], datasets['test'] else: return datasets['train'], datasets['test'] else: print 'preprocessing data...' pipeline = preprocessing.Pipeline() pipeline.items.append(preprocessing.GlobalContrastNormalization(use_std=True)) pipeline.items.append(preprocessing.ZCA()) # print 'traindata' # data = GalaxyZoo.gzdeepdata.GZData(which_set='training', start=0, stop=39999) # data.apply_preprocessor(preprocessor=pipeline, can_fit=True) # # this path can be used for visualizing weights after training is done # data.yaml_src = '!pkl: "%s"' % data # # save # data.use_design_loc(DATA_DIR+'train_design' + str(SUBMODEL) + '.npy') # serial.save(DATA_DIR+'gz_preprocessed_train'+str(SUBMODEL) + '.pkl', data) # print 'validdata' # data = GalaxyZoo.gzdeepdata.GZData(which_set='training', start=40000, stop=61577) # data.apply_preprocessor(preprocessor=pipeline, can_fit=False) # # this path can be used for visualizing weights after training is done # data.yaml_src = '!pkl: "%s"' % data # # save # data.use_design_loc(DATA_DIR+'valid_design' + str(SUBMODEL) + '.npy') # serial.save(DATA_DIR+'gz_preprocessed_valid'+str(SUBMODEL) + '.pkl', data) print 'tottraindata' data = GalaxyZoo.gzdeepdata.GZData(which_set='training', flatgrey=flatgrey) data.apply_preprocessor(preprocessor=pipeline, can_fit=True) # this path can be used for visualizing weights after training is done data.yaml_src = '!pkl: "%s"' % data # save data.use_design_loc(DATA_DIR + 'tottrain_design' + str(SUBMODEL) + '_64x.npy') serial.save(DATA_DIR + 'gz_preprocessed_tottrain' + str(SUBMODEL) + '_64x.pkl', data) print 'testdata' data = GalaxyZoo.gzdeepdata.GZData(which_set='test', flatgrey=flatgrey) data.apply_preprocessor(preprocessor=pipeline, can_fit=False) # this path can be used for visualizing weights after training is done data.yaml_src = '!pkl: "%s"' % data # save data.use_design_loc(DATA_DIR + 'test_design' + str(SUBMODEL) + '_64x.npy') serial.save(DATA_DIR + 'gz_preprocessed_test' + str(SUBMODEL) + '_64x.pkl', data) print 'Finished, now re-run for running model on GPU' return None, None
def get_dataset(which_data, tot=False): train_path = DATA_DIR + 'train' + which_data + '_preprocessed.pkl' valid_path = DATA_DIR + 'valid' + which_data + '_preprocessed.pkl' tottrain_path = DATA_DIR + 'tottrain' + which_data + '_preprocessed.pkl' test_path = DATA_DIR + 'test' + which_data + '_preprocessed.pkl' if os.path.exists(train_path) and os.path.exists( valid_path) and os.path.exists(test_path): print 'loading preprocessed data' trainset = serial.load(train_path) validset = serial.load(valid_path) if tot: tottrainset = serial.load(tottrain_path) testset = serial.load(test_path) else: print 'loading raw data...' trainset = Whales(which_set="train", which_data=which_data, start=0, stop=56671) validset = Whales(which_set="train", which_data=which_data, start=56671, stop=66671) tottrainset = Whales(which_set="train", which_data=which_data) testset = Whales(which_set="test", which_data=which_data) print 'preprocessing data...' pipeline = preprocessing.Pipeline() if which_data == 'melspectrum': pipeline.items.append( preprocessing.Standardize(global_mean=True, global_std=True)) # ZCA = zero-phase component analysis # very similar to PCA, but preserves the look of the original image better pipeline.items.append(preprocessing.ZCA()) else: # global_mean/std=False voor per-feature standardization pipeline.items.append( preprocessing.Standardize(global_mean=False, global_std=False)) trainset.apply_preprocessor(preprocessor=pipeline, can_fit=True) # this uses numpy format for storage instead of pickle, for memory reasons trainset.use_design_loc(DATA_DIR + 'train_' + which_data + '_design.npy') # note the can_fit=False: no sharing between train and test data validset.apply_preprocessor(preprocessor=pipeline, can_fit=False) validset.use_design_loc(DATA_DIR + 'valid_' + which_data + '_design.npy') tottrainset.apply_preprocessor(preprocessor=pipeline, can_fit=True) tottrainset.use_design_loc(DATA_DIR + 'tottrain_' + which_data + '_design.npy') # note the can_fit=False: no sharing between train and test data testset.apply_preprocessor(preprocessor=pipeline, can_fit=False) testset.use_design_loc(DATA_DIR + 'test_' + which_data + '_design.npy') # this path can be used for visualizing weights after training is done trainset.yaml_src = '!pkl: "%s"' % train_path validset.yaml_src = '!pkl: "%s"' % valid_path tottrainset.yaml_src = '!pkl: "%s"' % tottrain_path testset.yaml_src = '!pkl: "%s"' % test_path print 'saving preprocessed data...' serial.save(DATA_DIR + 'train' + which_data + '_preprocessed.pkl', trainset) serial.save(DATA_DIR + 'valid' + which_data + '_preprocessed.pkl', validset) serial.save(DATA_DIR + 'tottrain' + which_data + '_preprocessed.pkl', tottrainset) serial.save(DATA_DIR + 'test' + which_data + '_preprocessed.pkl', testset) if tot: return tottrainset, validset, testset else: return trainset, validset, testset
from pylearn2.utils import serial from pylearn2.datasets import preprocessing from pylearn2.datasets.tfd import TFD train = TFD(which_set='train') preprocessor = preprocessing.Pipeline() preprocessor.items.append(preprocessing.GlobalContrastNormalization()) preprocessor.items.append(preprocessing.ZCA()) preprocessor.apply(train, can_fit=True) serial.save('tfd_gcn_whitener.pkl', preprocessor)
def main(): data_name, model, pretrain, test, filter_channel, \ filter_size, activation, sparse_coeff, is_tied_weights, \ is_linear, do_zca, do_scale, do_maxpoool, n_epochs, batch_size = ProcessCommandLine() print '... Loading data and parameters' print 'dataset: ', data_name print 'filter_channel=', filter_channel print 'filter_size=', filter_size print 'activation=', activation print 'sparsity coefficient=', sparse_coeff print 'Max pooling=', do_maxpoool print 'tied weight=', is_tied_weights print 'linear CAE=', is_linear print 'ZCA whitening=', do_zca print 'Scale image=', do_scale print 'Batch size=', batch_size print 'number of epoch=', n_epochs # batch_size = 100 # number of images in each batch n_epochs = 100 # number of experiment epochs learning_rate = 0.1 # learning rate of SGD # filter_channel = 16 # number of feature maps in ConvAE # dataset = 'data/mnist.pkl.gz' # address of data # rng = np.random.RandomState(23455) # random generator # filter_size = 11 # n_images = 20 # sparse_coeff = 1 if sparse_coeff == 0: model_type = 'cae' else: model_type = 'spcae' model_save_name = model_type+'_'+data_name+'_'+ \ '[fn=%d,fs=%d,sp=%.3f,maxpool=%s,tied=%s,act=%s,linear=%s,ZCA=%s,scale=%s]' \ % (filter_channel, filter_size, sparse_coeff, do_maxpoool, is_tied_weights, activation, is_linear, do_zca, do_scale) results_dir = model_save_name + '/' # results_dir = data_name+'_'+model_name+'/' if not os.path.isdir(results_dir): os.mkdir(results_dir) if data_name == 'smallNORB': ### load smallNORB train set ### # norb = SmallNORB('train', True) # data_x = norb.adjust_for_viewer(norb.X) # data_y = norb.y # pickle.dump((data_x, data_y),open('smallNORB.pkl','wb'), -1) # results_dir = 'smallNORB_scae/' # results_dir = 'smallNORB_'+model_name+'/' # if not os.path.isdir(results_dir): # os.mkdir(results_dir) # f = open('smallNORB.pkl', 'r') # data, data_y = pickle.load(f) # _, feat = data.shape # f.close() # train = NORB(which_norb='small', which_set='train') # ipdb.set_trace() # window = preprocessing.CentralWindow(window_shape=(64,64)) # train.apply_preprocessor(preprocessor=window) # train.X = train.X.astype('float32') # zca = preprocessing.ZCA() # train.apply_preprocessor(preprocessor=zca, can_fit=True) # _, feat = train.X.shape # data_x = train.X[:, :feat/2] norb = sio.loadmat('smallNORB_matlab/smallNORB_train_32x32.mat') train_x = norb['trainData'].transpose(1, 0) if do_zca: zca = zca_whitening.ZCA() zca.fit(train_x) train_x = zca.transform(train_x) if do_scale: min_max_scaler = MinMaxScaler() train_x_T = min_max_scaler.fit_transform(train_x.T) train_x = train_x_T.T data_x = train_x idx = random.shuffle(range(data_x.shape[0])) data_x = data_x[idx, :][0, :, :] # ipdb.set_trace() im_channel = 1 im_height = 32 im_width = 32 elif data_name == 'cifar': ### load cifar10 ### # results_dir = 'cifar'+model_name+'/' # data_x = pickle.load(open('cifar10.pkl', 'r')) train = CIFAR10('train', gcn=55.) im_channel = 3 im_height = 32 im_width = 32 # min_max_scaler = MinMaxScaler() # data_x = min_max_scaler.fit_transform(data_x) # data_x = cifar10.X # elif data_name == 'cifarw': # ### load cifar10 ### # # results_dir = 'cifar'+model_name+'/' # # data_x = pickle.load(open('cifar10_whitened.pkl', 'r')) # train = CIFAR10('train', gcn=55.) # # zca = preprocessing.ZCA() # # cifar10.apply_preprocessor(preprocessor=zca, can_fit=True) # im_channel = 3 # im_height = 32 # im_width = 32 # min_max_scaler = MinMaxScaler() # data_x = min_max_scaler.fit_transform(cifar10.X) # data_x = cifar10.X # ipdb.set_trace() elif data_name == 'svhn': f = open('svhn.pkl', 'r') svhn = pickle.load(f) f.close() im_channel = 3 im_height = 32 im_width = 32 train_x, train_y = svhn[0] test_x, test_y = svhn[1] extra_x, extra_y = svhn[2] train_x = train_x.transpose([3, 2, 0, 1]) test_x = test_x.transpose([3, 2, 0, 1]) extra_x = extra_x.transpose([3, 2, 0, 1]) # Scale to [0,1] channel_scale_factor = train_x.max(axis=(2, 3)).astype('float32') train_x_scaled = train_x / channel_scale_factor.reshape( channel_scale_factor.shape[0], im_channel, 1, 1) data_x = train_x_scaled.reshape(train_x.shape[0], im_channel * im_height * im_width) elif data_name == 'mnist': # f = open('mnist.pkl', 'r') # mnist = pickle.load(f) # f.close() # train_x, train_y = mnist[0] # valid_x, valid_y = mnist[1] # test_x, test_y = mnist[2] # data_x = train_x train = MNIST('train') # zca = preprocessing.ZCA() # train.apply_preprocessor(preprocessor=zca, can_fit=True) # ipdb.set_trace() # min_max_scaler = MinMaxScaler() # data_x = min_max_scaler.fit_transform(train.X) # data_x = train.X # data_y = train.y im_channel = 1 im_height = 28 im_width = 28 elif data_name == 'bmnist': train = BinarizedMNIST(which_set='train') # zca = preprocessing.ZCA() # train.apply_preprocessor(preprocessor=zca, can_fit=True) # ipdb.set_trace() # min_max_scaler = MinMaxScaler() # data_x = min_max_scaler.fit_transform(train.X) # data_x = train.X # data_y = train.y im_channel = 1 im_height = 28 im_width = 28 if do_zca and data_name not in ['smallNORB', 'svhn']: zca = preprocessing.ZCA() train.apply_preprocessor(preprocessor=zca, can_fit=True) data_x = train.X pass if do_scale and data_name not in ['smallNORB', 'svhn']: min_max_scaler = MinMaxScaler() data_x_T = min_max_scaler.fit_transform(train.X.T) data_x = data_x_T.T pass if not do_zca and not do_scale and data_name not in ['smallNORB', 'svhn']: data_x = train.X # if data_name not in ['smallNORB']: # data_x = train.X n_samples, n_feat = data_x.shape data_x = data_x.reshape((n_samples, im_channel, im_height, im_width)) if data_name == 'mnist': data_x = data_x.transpose(0, 1, 3, 2) train_set_x = theano.shared(np.asarray(data_x, dtype=np.float32), borrow=True) # image_shp = (batch_size, im_channel, data_x.shape[2], data_x.shape[3]) image_shp = (batch_size, im_channel, im_height, im_width) filter_shp = (filter_channel, im_channel, filter_size, filter_size) print 'building model' cae1 = CAE(image_shape=image_shp, data=train_set_x, filter_shape=filter_shp, poolsize=(2, 2), sparse_coeff=sparse_coeff, activation=activation, do_max_pool=do_maxpoool, tied_weight=is_tied_weights, is_linear=is_linear) print 'model built' sys.stdout.flush() if model: cae1.load(model) pass if pretrain: do_pretraining_cae(data_name=data_name, model=cae1, save_name=model_save_name, image_shape=image_shp, result_dir=results_dir, max_epoch=n_epochs) elif test: do_visualize(data_name=data_name, model=cae1, result_dir=results_dir)