def test_histogram(self): image = np.array([[0, 1, 1, 3], [3, 1, 2, 2], [2, 0, 1, 2], [2, 0, 1, 2], [1, 3, 0, 1], [2, 2, 2, 3]]) expected = np.array([2, 2, 1, 1, 0, 2, 3, 1, 1, 1, 3, 1, 1, 2, 2, 1]) pcanet = PCANet(None, None, None, None, None, None, n_l2_output=2, block_shape=(3, 2)) # assume that n_l1_output = 2 assert_array_equal(pcanet.histogram(image), expected)
def __init__(self, n_estimators, sampling_ratio, n_jobs=-1, **transformer_params): """ n_estimators: int The number of estimators sampling_ratio: int The number of samples to draw from X to train each base transformer. n_jobs: int The number of jobs to run in parallel. The number of cores is set if -1. transformer_params: dict Parameters for PCANet.__init__ """ self.transformers = \ [PCANet(**transformer_params) for i in range(n_estimators)] # Validate only the first transformer # since all of transformers share the same hyperparameters self.transformers[0].validate_structure() self.estimators = [SVC(C=1e8) for i in range(n_estimators)] self.sampling_ratio = sampling_ratio self.n_jobs = n_jobs if n_jobs == -1: self.n_jobs = cpu_count()
def test_histogram(self): images = xp.array([[[0, 1, 1, 3], [3, 1, 2, 2], [2, 0, 1, 2], [0, 1, 1, 1]], [[2, 0, 1, 2], [1, 3, 0, 1], [2, 2, 2, 3], [1, 3, 3, 1]]]) expected = xp.array([[1, 2, 0, 1, 0, 1, 2, 1, 2, 1, 1, 0, 0, 3, 1, 0], [1, 1, 1, 1, 1, 2, 1, 0, 0, 1, 2, 1, 0, 1, 1, 2]]) pcanet = PCANet(None, None, None, None, None, None, n_l2_output=2, filter_shape_pooling=2, step_shape_pooling=2) assert_array_equal(pcanet.histogram(images), expected) images = xp.array([[[1, 0, 1], [2, 0, 0], [1, 3, 3]], [[2, 0, 0], [1, 1, 1], [3, 0, 1]]]) expected = xp.array([[2, 1, 1, 0, 3, 1, 0, 0, 1, 1, 1, 1, 2, 0, 0, 2], [1, 2, 1, 0, 2, 2, 0, 0, 1, 2, 0, 1, 1, 3, 0, 0]]) pcanet = PCANet(None, None, None, None, None, None, n_l2_output=2, filter_shape_pooling=2, step_shape_pooling=1) assert_array_equal(pcanet.histogram(images), expected)
def run_pcanet_normal(transformer_params, images_train, images_test, y_train, y_test): model = PCANet(**transformer_params) model.validate_structure() t1 = timeit.default_timer() model.fit(images_train) t2 = timeit.default_timer() train_time = t2 - t1 t1 = timeit.default_timer() X_train = model.transform(images_train) t2 = timeit.default_timer() transform_time = t2 - t1 X_test = model.transform(images_test) y_test, y_pred = run_classifier(X_train, X_test, y_train, y_test) accuracy = accuracy_score(y_test, y_pred) return model, accuracy, train_time, transform_time
for i, class_id in itertools.product(range(nexamples), range(nclasses)): ax[i, class_id].imshow(train_set_X[img_idx[class_id][i]], cmap='gray') ax[i, class_id].get_xaxis().set_visible(False) ax[i, class_id].get_yaxis().set_visible(False) plt.savefig('mnist.png', bbox_inches='tight', facecolor='black', pad_inches=0) plt.show() # %% # Convert to NCHW train_set_X = train_set_X[:, None, ...] test_set_X = test_set_X[:, None, ...] # %% print(' ====== PCANet Training ======= ') net = PCANet([8, 8], 7, 7, 0.5) time_start = time.time() train_features = net.extract_features(train_set_X) train_features = scipy.sparse.csr_matrix(train_features) time_end = time.time() print('Time cost %.2f s' % (time_end - time_start)) del train_set_X #%% #visualize PCA filter banks fig, ax = plt.subplots(2, 8, figsize=(16, 4), facecolor='black') for stage, i in itertools.product(range(2), range(8)): filter_bank = eval('net.W_' + str(stage + 1))[:, i].reshape(7, 7) ax[stage, i].imshow(filter_bank, cmap='gray') ax[stage, i].get_xaxis().set_visible(False) ax[stage, i].get_yaxis().set_visible(False)
def main(): day_str = "{:%B_%d}".format(datetime.now()) time_str = "{:%H_%M_%S}".format(datetime.now()) day_dir = "log_data/" + day_str + "/" log_path = day_dir + day_str + "_" + time_str + "/" writer = tf.summary.FileWriter(log_path) # Open text editor to write description of the run and commit it if '--temp' not in sys.argv: if '-m' in sys.argv: m_i = sys.argv.index('-m') msg = sys.argv[m_i + 1] cmd = ['git', 'commit', '*.py', '-m', msg] else: cmd = ['git', 'commit', '*.py'] os.environ['TF_LOG_DIR'] = log_path call(cmd) # setup the input data pipelines train_image_batch, train_label_batch, test_image_batch, test_label_batch, info = load( 'mnist') # train_image_batch, train_label_batch, test_image_batch, test_label_batch, info = load('cifar10') sess = tf.Session() tf.train.start_queue_runners(sess=sess) if '--debug' in sys.argv: sess = tf_debug.LocalCLIDebugWrapperSession(sess) sess.add_tensor_filter("has_inf_or_nan", tf_debug.has_inf_or_nan) sess.add_tensor_filter("greater_than_or_equal_to", gre_filter) init = tf.global_variables_initializer() # Hyper-params k1 = 7 k2 = 7 l1 = 8 l2 = 8 block_w = 4 block_h = 4 block_overlap = 0 num_hist_bins = 2**l2 stride_w = max(int((1 - block_overlap) * block_w), 1) stride_h = max(int((1 - block_overlap) * block_h), 1) w_steps = range(block_w, info.IMAGE_W + 1, stride_w) h_steps = range(block_h, info.IMAGE_H + 1, stride_h) print(list(w_steps)) num_blocks = len(h_steps) * len(w_steps) hyperparams = { 'l1': l1, 'l2': l2, 'k1': k1, 'k2': k2, 'num_hist_bins': num_hist_bins, 'block_w': block_w, 'block_h': block_h, 'stride_w': stride_w, 'stride_h': stride_h, 'num_blocks': num_blocks, } # check that the blocks in the final step to be even & cover all pixels if w_steps[-1] != info.IMAGE_W: print("invalid block_overlap or block width for given image width:") print("W: %i, Block W: %i, Overlap: %0.2f" % (info.IMAGE_W, block_w, block_overlap)) exit(0) if h_steps[-1] != info.IMAGE_H: print("invalid block_overlap or block height for given image height") print("H: %i, Block H: %i, Overlap: %0.2f" % (info.IMAGE_H, block_h, block_overlap)) exit(0) # define the model m = PCANet(train_image_batch, hyperparams, info) # define placeholders for putting scores on Tensorboard train_score_tensor = tf.placeholder(tf.float32, shape=[], name='train_score') test_score_tensor = tf.placeholder(tf.float32, shape=[], name='test_score') tf.summary.scalar("train_score", train_score_tensor, collections=['train']) tf.summary.scalar("test_score", test_score_tensor, collections=['test']) # run it sess.run(init) writer.add_graph(sess.graph) merged_summary_op = tf.summary.merge_all('summaries') train_summary_op = tf.summary.merge_all('train') test_summary_op = tf.summary.merge_all('test') # extract PCA features from training set train_pcanet_features, train_labels, summary = sess.run( [m.output_features, train_label_batch, merged_summary_op]) writer.add_summary(summary, 0) # train linear SVM svm = LinearSVC(C=1.0, fit_intercept=False) svm.fit(train_pcanet_features, train_labels) train_score = svm.score(train_pcanet_features, train_labels) print("training score:", train_score) train_summary = sess.run(train_summary_op, feed_dict={train_score_tensor: train_score}) writer.add_summary(train_summary, 0) # switch to test set, compute PCA filters, and score with learned SVM parameters scores = [] m = PCANet(test_image_batch, hyperparams, info) for i in range(4): test_pcanet_features, test_labels, merged_summary = sess.run( [m.output_features, test_label_batch, merged_summary_op]) writer.add_summary(merged_summary, i + 1) score = svm.score(test_pcanet_features, test_labels) scores.append(score) print("batch test score:", score) test_summary = sess.run(test_summary_op, feed_dict={test_score_tensor: score}) writer.add_summary(test_summary, i + 1) print("Final score on test set: ", sum(scores) / len(scores)) writer.close()
def main(): if not torch.cuda.is_available(): logging.info('no gpu device available') sys.exit(1) logging.info('gpu device = %d' % args.gpu) logging.info("args = %s", args) pcanet = PCANet(args.stages, args.filter_shape, args.stages_channels, args.block_size, args.block_overlap) train_queue, valid_queue = load_train_mnist(args) # load dataset logging.info("load training dataset completely") total_train_labels = torch.tensor([]).long() writer = SummaryWriter(args.save) # tensorboardX # extract feature from images with torch.no_grad(): # first of all, generate eigenvector, and then execute convolution stage_save_path = args.save save_filename = utils.create_pickle_file_name(stage_save_path, 0) for global_step, (train_images, train_labels) in enumerate(train_queue): train_images = train_images.cuda() total_train_labels = torch.cat((total_train_labels, train_labels)) utils.save_feature([train_images, train_labels], save_filename) pcanet.unrolled_stage(train_images, 0) if global_step % args.log_freq == 0: logging.info("init training global_step: %d" % global_step) # convert a batch of tensor into CHW format grid_images = make_grid(train_images, nrow=16, padding=5, pad_value=125) writer.add_image("raw_images_in_step_%d" % global_step, grid_images) total_features = torch.tensor([]) # empty tensor for stage in range(args.stages): logging.info('PCANet stage: %d' % stage) # transform eigenvector to convolution kernel kernel = pcanet.eigenvector_to_kernel(stage) load_filename = utils.create_pickle_file_name( stage_save_path, stage) if stage + 1 < args.stages: save_filename = utils.create_pickle_file_name( stage_save_path, stage + 1) load_filename_pointer = 0 # clear file object pointer for step in range(global_step + 1): train_images, train_labels, load_filename_pointer = \ utils.load_feature(load_filename, load_filename_pointer) batch_features = pcanet.pca_conv(train_images, kernel) if step % args.log_freq == 0: # view the i-th image's feature map in a single batch single_image_feature = utils.exchange_channel( batch_features[5]) grid_images = make_grid(single_image_feature, nrow=8, padding=5, pad_value=125) writer.add_image( "feature_image_in_step_%d_in_stage_%d" % (step, stage), grid_images) if stage + 1 < args.stages: utils.save_feature([batch_features, train_labels], save_filename) pcanet.unrolled_stage(batch_features, stage + 1) else: decimal_features = pcanet.binary_mapping( batch_features, stage) final_features = pcanet.generate_histogram( decimal_features) final_features = final_features.cpu() total_features = torch.cat( (total_features, final_features), dim=0) if step % args.log_freq == 0: logging.info("circulate training step: %d" % step) grid_kernels = make_grid(pcanet.kernel[stage], nrow=args.stages_channels[stage], padding=5, pad_value=125) writer.add_image("kernel_in_stage_%d" % stage, grid_kernels) writer.close() logging.info('extract feature completely, start training classifier') # train classifier classifier = LinearSVC() # classifier = SVC() # total_features = total_features.cpu() classifier.fit(total_features, total_train_labels) logging.info('classifier trained completely') # save model utils.save_model(pcanet, stage_save_path + "/pcanet.pkl") utils.save_model(classifier, stage_save_path + "/classifier.pkl") train_score = classifier.score(total_features, total_train_labels) logging.info("score of training is %s" % train_score)
def test_validate_structure(self): # Check whether filters visit all pixels of input images pcanet = PCANet(image_shape=9, filter_shape_l1=3, step_shape_l1=2, n_l1_output=1, filter_shape_l2=3, step_shape_l2=1, n_l2_output=1, filter_shape_pooling=1, step_shape_pooling=1) pcanet.validate_structure() pcanet = PCANet(image_shape=10, filter_shape_l1=3, step_shape_l1=2, n_l1_output=1, filter_shape_l2=3, step_shape_l2=1, n_l2_output=1, filter_shape_pooling=1, step_shape_pooling=1) self.assertRaises(ValueError, pcanet.validate_structure) # Check whether filters visit all pixels of L1 output # the shape of L1 output is (6, 6) pcanet = PCANet(image_shape=13, filter_shape_l1=3, step_shape_l1=2, n_l1_output=1, filter_shape_l2=3, step_shape_l2=1, n_l2_output=1, filter_shape_pooling=1, step_shape_pooling=1) pcanet.validate_structure() pcanet = PCANet(image_shape=13, filter_shape_l1=3, step_shape_l1=2, n_l1_output=1, filter_shape_l2=3, step_shape_l2=2, n_l2_output=1, filter_shape_pooling=1, step_shape_pooling=1) self.assertRaises(ValueError, pcanet.validate_structure) # Check whether blocks cover all pixels of L2 output # the shape of L1 output is (9, 9) # the shape of L2 output is (4, 4) pcanet = PCANet(image_shape=19, filter_shape_l1=3, step_shape_l1=2, n_l1_output=1, filter_shape_l2=3, step_shape_l2=2, n_l2_output=1, filter_shape_pooling=2, step_shape_pooling=2) pcanet.validate_structure() pcanet = PCANet(image_shape=19, filter_shape_l1=3, step_shape_l1=2, n_l1_output=1, filter_shape_l2=3, step_shape_l2=2, n_l2_output=1, filter_shape_pooling=3, step_shape_pooling=1) self.assertRaises(ValueError, pcanet.validate_structure)
train_set, valid_set, test_set = load_mnist() images_train, y_train = train_set images_test, y_test = test_set images_train, y_train = shuffle(images_train, y_train, random_state=0) images_train, y_train = images_train[:n_train], y_train[:n_train] images_test, y_test = shuffle(images_test, y_test, random_state=0) images_test, y_test = images_test[:n_test], y_test[:n_test] pcanet = PCANet(image_shape=28, filter_shape_l1=2, step_shape_l1=1, n_l1_output=4, filter_shape_l2=2, step_shape_l2=1, n_l2_output=4, block_shape=2) pcanet.validate_structure() pcanet.fit(images_train) X_train = pcanet.transform(images_train) X_test = pcanet.transform(images_test) model = RandomForestClassifier(n_estimators=100, random_state=1234, n_jobs=-1) model.fit(X_train, y_train) y_pred = model.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("accuracy: " + str(accuracy))
ax[i, class_id].imshow(train_set_X[img_idx[class_id][i]]) ax[i, class_id].get_xaxis().set_visible(False) ax[i, class_id].get_yaxis().set_visible(False) plt.savefig('cifar10.png', bbox_inches='tight') plt.show() #%% # Convert to NCHW train_set_X = train_set_X.permute(0, 3, 1, 2) test_set_X = test_set_X.permute(0, 3, 1, 2) #%% print(' ====== PCANet Training ======= ') # net = PCANet([40, 8], 5, 8, 0.5) net = PCANet([40, 8], 5, 8, 0.5, [4, 2, 1]) time_start = time.time() train_features = net.extract_features(train_set_X) train_features = scipy.sparse.csr_matrix(train_features) time_end = time.time() print('Time cost %.2f s' % (time_end - time_start)) del train_set_X #%% #visualize PCA filter banks fig, ax = plt.subplots(5, 8, figsize=(16, 10), facecolor='black') for r, c in itertools.product(range(5), range(8)): # convert to HWC filter_bank = net.W_1[:, r * 8 + c].reshape(3, 5, 5).permute(1, 2, 0) #scale to [0, 1] filter_bank = np.interp(filter_bank,