parameters used in whitening (i.e., the ZCA whitening matrix and the mean_patch) """ # Loading the learned features and preprocessing matrices load_data = joblib.load("data/STL10_features.pkl") opt_theta = load_data['opt_theta'] zca_white = load_data['zca_white'] mean_patch = load_data['mean_patch'] W = opt_theta[0:visible_size * hidden_size].reshape((hidden_size, visible_size)) b = opt_theta[2*hidden_size*visible_size:2*hidden_size*visible_size + hidden_size] # Display and check to see that the features look good image = display_color_network( (W.dot(zca_white)).T ) plt.imsave('cnn_learned_features.png', image) plt.imshow(image) """ STEP 2: Implement and test convolution and pooling In this step, you will implement convolution and pooling, and test them on a small part of the data set to ensure that you have implemented these two functions correctly. In the next step, you will actually convolve and pool the features with the STL10 images. """ """ STEP 2a: Implement convolution Implement convolution in the function cnnConvolve in cnnConvolve.m """ # Note that we have to preprocess the images in the exact same way
def test_nuclei(): '''Test the convolutional autoencder using nuclei.''' # %% random.seed(datetime.now()) RANDOM_SEED_MAGIC = random.randint(0, 65536) nuclei_training_dataset = NucleiDataset( mat_file='tmi/training/training.mat', random_seed=RANDOM_SEED_MAGIC, k=10, m_list=[0, 1, 2, 3, 4, 5, 6, 7, 8]) nuclei_test_dataset = NucleiDataset(mat_file='tmi/training/training.mat', random_seed=RANDOM_SEED_MAGIC, k=10, m_list=[9]) nuclei_data, _ = nuclei_training_dataset[random.sample( range(nuclei_training_dataset.__len__()), 1000)] mean_img = np.mean(nuclei_data, axis=0) xae_learning_rate = 0.01 smc_learning_rate = 0.0001 n_xae_batch_size = 1000 n_smc_batch_size = 1000 n_xae_epochs = 10000 n_smc_epochs = 20000 n_xae_reload_per_epochs = 1000 n_xae_display_per_epochs = 1000 n_smc_reload_per_epochs = 1000 n_smc_display_per_epochs = 1000 xae_layers = [ { 'n_channels': 144, 'reconstructive_regularizer': 1.0, 'weight_decay': 1.0, 'sparse_regularizer': 1.0, 'sparsity_level': 0.05, 'exclusive_regularizer': 1.0, 'corrupt_prob': 1.0, 'tied_weight': True, 'exclusive_type': 'logcosh', 'exclusive_scale': 10.0, 'gaussian_mean': 0.0, 'gaussian_std': 0.0, 'encode': 'sigmoid', 'decode': 'linear', 'pathways': [ range(0, 96), range(48, 144), ], }, ] ae = eXclusiveAutoencoder( input_dimensions=nuclei_data.shape[1], layers=xae_layers, init_encoder_weight=None, init_decoder_weight=None, init_encoder_bias=None, init_decoder_bias=None, ) smc = SoftmaxClassifier( input_dimensions=144, output_dimensions=2, ) # smc = FullyConnectedNetwork( # dimensions = [1024, 256, 128, 64, 2], # init_weight = None, # init_bias = None, # ) xae_optimizer_list = [] for layer_i in range(len(xae_layers)): xae_optimizer_list.append( tf.train.AdamOptimizer(xae_learning_rate).minimize( ae['layerwise_cost'][layer_i]['total'], var_list=[ ae['encoder_weight'][layer_i], ae['encoder_bias'][layer_i], # ae['decoder_weight'][layer_i], # ae['decoder_bias'][layer_i], ])) xae_optimizer_full = tf.train.AdamOptimizer(xae_learning_rate).minimize( ae['cost']['total']) smc_optimizer = tf.train.AdamOptimizer(smc_learning_rate).minimize( smc['cost']) # smc_optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9).minimize(smc['cost']) # fcn_optimizer = tf.train.AdamOptimizer(learning_rate).minimize(fc['cost']) # correct_prediction = tf.equal(tf.argmax(smc['y'], 1), tf.argmax(smc['y_'], 1)) # accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # %% # We create a session to use the graph sess = tf.Session() writer = tf.summary.FileWriter('logs', sess.graph) sess.run(tf.global_variables_initializer()) # %% # Fit all training data for layer_i in range(len(xae_layers)): for epoch_i in range(n_xae_epochs): if (epoch_i) % n_xae_reload_per_epochs == 0: batch_xs, batch_ys = nuclei_training_dataset[random.sample( range(nuclei_training_dataset.__len__()), n_xae_batch_size)] train = [] train.append( np.array([ img - mean_img for img in batch_xs[np.where( np.any( np.array([ batch_ys[:, 0], # batch_ys[:, 1], ]) == 1, axis=0))] ])) train.append( np.array([ img - mean_img for img in batch_xs[np.where( np.any( np.array([ # batch_ys[:, 0], batch_ys[:, 1], ]) == 1, axis=0))] ])) sess.run(xae_optimizer_list[layer_i], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) if (epoch_i + 1) % n_xae_display_per_epochs == 0: cost_total = sess.run(ae['layerwise_cost'][layer_i]['total'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_reconstruction_error = sess.run( ae['layerwise_cost'][layer_i]['reconstruction_error'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_sparsity = sess.run( ae['layerwise_cost'][layer_i]['sparsity'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_exclusivity = sess.run( ae['layerwise_cost'][layer_i]['exclusivity'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_weight_decay = sess.run( ae['layerwise_cost'][layer_i]['weight_decay'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) print('layer:', layer_i + 1, ', epoch:', epoch_i + 1, ', total cost:', cost_total, ', recon error:', cost_reconstruction_error, ', sparsity:', cost_sparsity, ', weight decay:', cost_weight_decay, ', exclusivity: ', cost_exclusivity) test_xs, test_ys = nuclei_training_dataset[random.sample( range(nuclei_training_dataset.__len__()), 2000)] test_xs_0 = np.array([ img - mean_img for img in test_xs[np.where( np.any( np.array([ test_ys[:, 0], # test_ys[:, 1], ]) == 1, axis=0))][:144] ]) recon_0 = sess.run(ae['layerwise_y'][layer_i], feed_dict={ae['x']: test_xs_0}) test_xs_1 = np.array([ img - mean_img for img in test_xs[np.where( np.any( np.array([ # test_ys[:, 0], test_ys[:, 1], ]) == 1, axis=0))][:144] ]) recon_1 = sess.run(ae['layerwise_y'][layer_i], feed_dict={ae['x']: test_xs_1}) weights = sess.run(ae['encoder_weight'][0]) display_color_network(weights, filename='nuclei_weights.png') display_color_network(test_xs_0.transpose(), filename='nuclei_test_0.png') display_color_network(recon_0.transpose(), filename='nuclei_results_0.png') display_color_network(test_xs_1.transpose(), filename='nuclei_test_1.png') display_color_network(recon_1.transpose(), filename='nuclei_results_1.png') for epoch_i in range(n_xae_epochs): if (epoch_i) % n_xae_reload_per_epochs == 0: batch_xs, batch_ys = nuclei_training_dataset[random.sample( range(nuclei_training_dataset.__len__()), n_xae_batch_size)] train = [] train.append( np.array([ img - mean_img for img in batch_xs[np.where( np.any( np.array([ batch_ys[:, 0], # batch_ys[:, 1], ]) == 1, axis=0))] ])) train.append( np.array([ img - mean_img for img in batch_xs[np.where( np.any( np.array([ # batch_ys[:, 0], batch_ys[:, 1], ]) == 1, axis=0))] ])) sess.run(xae_optimizer_full, feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) if (epoch_i + 1) % n_xae_display_per_epochs == 0: cost_total = sess.run(ae['cost']['total'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_reconstruction_error = sess.run( ae['cost']['reconstruction_error'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_sparsity = sess.run(ae['cost']['sparsity'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_exclusivity = sess.run(ae['cost']['exclusivity'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) cost_weight_decay = sess.run(ae['cost']['weight_decay'], feed_dict={ ae['training_x'][0]: train[0], ae['training_x'][1]: train[1] }) print('layer: full,', 'epoch:', epoch_i + 1, ', total cost:', cost_total, ', recon error:', cost_reconstruction_error, ', sparsity:', cost_sparsity, ', weight decay:', cost_weight_decay, ', exclusivity: ', cost_exclusivity) n_examples = 5120 test_xs, test_ys = nuclei_training_dataset[random.sample( range(nuclei_training_dataset.__len__()), n_examples)] test_xs_0 = np.array([ img - mean_img for img in test_xs[np.where( np.any( np.array([ test_ys[:, 0], # test_ys[:, 1], ]) == 1, axis=0))][:144] ]) recon_0 = sess.run(ae['y'], feed_dict={ae['x']: test_xs_0}) test_xs_1 = np.array([ img - mean_img for img in test_xs[np.where( np.any( np.array([ # test_ys[:, 0], test_ys[:, 1], ]) == 1, axis=0))][:144] ]) recon_1 = sess.run(ae['y'], feed_dict={ae['x']: test_xs_1}) weights = sess.run(ae['encoder_weight'][0]) display_color_network(weights, filename='nuclei_weights.png') display_color_network(test_xs_0.transpose(), filename='nuclei_test_0.png') display_color_network(recon_0.transpose(), filename='nuclei_results_0.png') display_color_network(test_xs_1.transpose(), filename='nuclei_test_1.png') display_color_network(recon_1.transpose(), filename='nuclei_results_1.png') for epoch_i in range(n_smc_epochs): if (epoch_i) % n_smc_reload_per_epochs == 0: batch_xs, batch_ys = nuclei_training_dataset[random.sample( range(nuclei_training_dataset.__len__()), n_smc_batch_size)] ae_z = sess.run(ae['z'], feed_dict={ae['x']: batch_xs}) sess.run(smc_optimizer, feed_dict={ smc['x']: ae_z, smc['y_']: batch_ys, smc['keep_prob_input']: 0.9, smc['keep_prob']: 0.9 }) if (epoch_i + 1) % n_smc_display_per_epochs == 0: cost = sess.run(smc['cost'], feed_dict={ smc['x']: ae_z, smc['y_']: batch_ys, smc['keep_prob_input']: 1.0, smc['keep_prob']: 1.0 }) test_xs, test_ys = nuclei_test_dataset[random.sample( range(nuclei_test_dataset.__len__()), n_smc_batch_size)] ae_z = sess.run(ae['z'], feed_dict={ae['x']: test_xs}) acc = sess.run(smc['accuracy'], feed_dict={ smc['x']: ae_z, smc['y_']: test_ys, smc['keep_prob_input']: 1.0, smc['keep_prob']: 1.0 }) print('epoch:', epoch_i + 1, ', cost:', cost, ', accuracy:', acc) test_xs, test_ys = nuclei_test_dataset[:] ae_z = sess.run(ae['z'], feed_dict={ae['x']: test_xs}) y = sess.run(smc['y'], feed_dict={ smc['x']: ae_z, smc['y_']: test_ys, smc['keep_prob_input']: 1.0, smc['keep_prob']: 1.0 }) prediction = sess.run(smc['prediction'], feed_dict={ smc['x']: ae_z, smc['y_']: test_ys, smc['keep_prob_input']: 1.0, smc['keep_prob']: 1.0 }) conf_matrix = confusion_matrix(np.argmax(test_ys, axis=1), prediction) # with open('nuclei_results_0.csv', "wb") as csv_file: # csvwriter = csv.writer(csv_file, delimiter=str(u',')) # for (p, y, g) in zip(prediction[:, 1], y[:, 1], test_ys[:, 1]): # csvwriter.writerow([p, y, g]) num_labels = 2 print('final f1_score:', f1_score(test_ys[:, 1], prediction, average="macro")) print('final precision:', precision_score(test_ys[:, 1], prediction, average="macro")) print('final recall:', recall_score(test_ys[:, 1], prediction, average="macro")) print('final average_precision:', average_precision_score(test_ys[:, 1], prediction, average="macro")) print( 'final accuracy:', sess.run(smc['accuracy'], feed_dict={ smc['x']: ae_z, smc['y_']: test_ys, smc['keep_prob_input']: 1.0, smc['keep_prob']: 1.0 })) sys.stdout.write('\n\nConfusion Matrix') sys.stdout.write('\t' * (num_labels - 2) + '| Accuracy') sys.stdout.write('\n' + '-' * 8 * (num_labels + 1)) sys.stdout.write('\n') for i in range(len(conf_matrix)): for j in range(len(conf_matrix[i])): sys.stdout.write(str(conf_matrix[i][j].astype(np.int)) + '\t') sys.stdout.write('| %3.2f %%' % (conf_matrix[i][i] * 100 / conf_matrix[i].sum())) sys.stdout.write('\n') sys.stdout.write('Number of test samples: %i \n\n' % conf_matrix.sum()) fpr = dict() tpr = dict() roc_auc = dict() for i in range(num_labels): fpr[i], tpr[i], _ = roc_curve(test_ys[:, i], y[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) # Compute micro-average ROC curve and ROC area fpr["micro"], tpr["micro"], _ = roc_curve(test_ys.ravel(), y.ravel()) roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) # First aggregate all false positive rates # all_fpr = np.unique(np.concatenate([fpr[i] for i in range(num_labels)])) # Then interpolate all ROC curves at this points # mean_tpr = np.zeros_like(all_fpr) # for i in range(num_labels): # mean_tpr += interp(all_fpr, fpr[i], tpr[i]) # Finally average it and compute AUC # mean_tpr /= num_labels # fpr["macro"] = all_fpr # tpr["macro"] = mean_tpr # roc_auc["macro"] = auc(fpr["macro"], tpr["macro"]) # Plot all ROC curves # plt.plot(fpr["micro"], tpr["micro"], # label='micro-average ROC curve (area = {0:0.3f})' # ''.format(roc_auc["micro"]), # color='red', linestyle=':', linewidth=4) # # plt.plot(fpr["macro"], tpr["macro"], # label='macro-average ROC curve (area = {0:0.3f})' # ''.format(roc_auc["macro"]), # color='blue', linestyle=':', linewidth=4) # cmap = matplotlib.cm.get_cmap('rainbow') # colors = [cmap(0.1+0.8*float(i)/float(num_labels-1)) for i in range(num_labels)] # label_list = ['Epithelial', 'Inflammatory', 'Fibroblast', 'Miscellaneous'] # colors = cycle(['aqua', 'darkorange', 'cornflowerblue']) # for i, color in zip(range(num_labels), colors): plt.plot(fpr[0], tpr[0], color='darkorange', lw=2, label='ROC curve (area = {0:0.3f})'.format(roc_auc[0])) plt.plot([0, 1], [0, 1], 'k--', lw=2) plt.xlim([-0.01, 1.0]) plt.ylim([0.0, 1.015]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver Operating Characteristic (ROC) Curves') plt.legend(loc="lower right") plt.gcf().savefig('rocplot.png') plt.clf() writer.close()
## STEP 1: Train a sparse autoencoder (with a linear decoder) to learn # features from color patches. If you have completed the linear decoder # execise, use the features that you have obtained from that exercise, # loading them into optTheta. Recall that we have to keep around the # parameters used in whitening (i.e., the ZCA whitening matrix and the # meanPatch) with open('stl10_features.pickle', 'r') as f: opt_theta = pickle.load(f) zca_white = pickle.load(f) patch_mean = pickle.load(f) # Display and check to see that the features look good W = opt_theta[0:hidden_size * visible_size].reshape(hidden_size, visible_size) b = opt_theta[2 * hidden_size * visible_size:2 * hidden_size * visible_size + hidden_size] display_network.display_color_network( W.dot(zca_white).transpose(), 'zca_features_test.png') ##====================================================================== ## STEP 2: Implement and test convolution and pooling # In this step, you will implement convolution and pooling, and test them # on a small part of the data set to ensure that you have implemented # these two functions correctly. In the next step, you will actually # convolve and pool the features with the STL10 images. ## STEP 2a: Implement convolution # Implement convolution in the function cnnConvolve in cnnConvolve.m # Note that we have to preprocess the images in the exact same way # we preprocessed the patches before we can obtain the feature activations. stl_train = scipy.io.loadmat('data/stlTrainSubset.mat')
print diff print "Norm of the difference between numerical and analytical num_grad (should be < 1e-9)\n\n" ##====================================================================== ## STEP 2: Learn features on small patches # In this step, you will use your sparse autoencoder (which now uses a # linear decoder) to learn features on small patches sampled from related # images. ## STEP 2a: Load patches # In this step, we load 100k patches sampled from the STL10 dataset and # visualize them. Note that these patches have been scaled to [0,1] patches = scipy.io.loadmat('data/stlSampledPatches.mat')['patches'] display_network.display_color_network(patches[:, 0:100], filename='patches_raw.png') ## STEP 2b: Apply preprocessing # In this sub-step, we preprocess the sampled patches, in particular, # ZCA whitening them. # # In a later exercise on convolution and pooling, you will need to replicate # exactly the preprocessing steps you apply to these patches before # using the autoencoder to learn features on them. Hence, we will save the # ZCA whitening and mean image matrices together with the learned features # later on. # Subtract mean patch (hence zeroing the mean of the patches) patch_mean = np.mean(patches, 1) patches = patches - np.tile(patch_mean, (patches.shape[1], 1)).transpose()
# reinitialize the parameters """ STEP 2: Learn features on small patches In this step, you will use your sparse autoencoder (which now uses a linear decoder) to learn features on small patches sampled from related images. """ """ STEP 2a: Load patches In this step, we load 100k patches sampled from the STL10 dataset and visualize them. Note that these patches have been scaled to [0,1] """ patches = scipy.io.loadmat('data/stlSampledPatches.mat')['patches'] image = display_color_network(patches[:, :100]) plt.imsave('linear_decoder_raw_patches.png', image) #plt.imshow(image) """ STEP 2b: Apply preprocessing In this sub-step, we preprocess the sampled patches, in particular, ZCA whitening them. In a later exercise on convolution and pooling, you will need to replicate exactly the preprocessing steps you apply to these patches before using the autoencoder to learn features on them. Hence, we will save the ZCA whitening and mean image matrices together with the learned features later on. """ # Subtract mean patch (hence zeroing the mean of the patches)
""" STEP 2: Learn features on small patches In this step, you will use your sparse autoencoder (which now uses a linear decoder) to learn features on small patches sampled from related images. """ """ STEP 2a: Load patches In this step, we load 100k patches sampled from the STL10 dataset and visualize them. Note that these patches have been scaled to [0,1] """ patches = scipy.io.loadmat('data/stlSampledPatches.mat')['patches'] image = display_color_network(patches[:, :100]) plt.imsave('linear_decoder_raw_patches.png', image) #plt.imshow(image) """ STEP 2b: Apply preprocessing In this sub-step, we preprocess the sampled patches, in particular, ZCA whitening them. In a later exercise on convolution and pooling, you will need to replicate exactly the preprocessing steps you apply to these patches before using the autoencoder to learn features on them. Hence, we will save the ZCA whitening and mean image matrices together with the learned features later on. """
##====================================================================== ## STEP 1: Train a sparse autoencoder (with a linear decoder) to learn # features from color patches. If you have completed the linear decoder # execise, use the features that you have obtained from that exercise, # loading them into optTheta. Recall that we have to keep around the # parameters used in whitening (i.e., the ZCA whitening matrix and the # meanPatch) with open('stl10_features.pickle', 'r') as f: opt_theta = pickle.load(f) zca_white = pickle.load(f) patch_mean = pickle.load(f) # Display and check to see that the features look good W = opt_theta[0:hidden_size * visible_size].reshape(hidden_size, visible_size) b = opt_theta[2 * hidden_size * visible_size:2 * hidden_size * visible_size + hidden_size] display_network.display_color_network(W.dot(zca_white).transpose(), 'zca_features_test.png') ##====================================================================== ## STEP 2: Implement and test convolution and pooling # In this step, you will implement convolution and pooling, and test them # on a small part of the data set to ensure that you have implemented # these two functions correctly. In the next step, you will actually # convolve and pool the features with the STL10 images. ## STEP 2a: Implement convolution # Implement convolution in the function cnnConvolve in cnnConvolve.m # Note that we have to preprocess the images in the exact same way # we preprocessed the patches before we can obtain the feature activations.
def train_lymphocyte(output_file, input_folder): '''Test the convolutional autoencder using lymphocyte.''' # %% lymphocyte_training_dataset = LymphocyteDataset( input_folder, patch_size=PATCH_SIZE, random_seed=RANDOM_SEED_MAGIC, k=10, m_list=[0, 1, 2, 3, 4, 5, 6, 7, 8]) lymphocyte_test_dataset = LymphocyteDataset(input_folder, patch_size=PATCH_SIZE, random_seed=RANDOM_SEED_MAGIC, k=10, m_list=[9]) lymphocyte_data, _ = lymphocyte_training_dataset[random.sample( range(lymphocyte_training_dataset.__len__()), 1000)] mean = np.mean(lymphocyte_data, axis=0) xae_learning_rate = 0.0002 fcn_learning_rate = 0.0002 n_xae_batch_size = 1000 n_fcn_batch_size = 1000 n_xae_epochs = 100000 n_fcn_epochs = 100000 n_xae_reload_per_epochs = 1000 n_xae_display_per_epochs = 10000 n_fcn_reload_per_epochs = 1000 n_fcn_display_per_epochs = 10000 xae_layers = [ { 'n_channels': 225, 'reconstructive_regularizer': 1.0, 'weight_decay': 1.0, 'sparse_regularizer': 1.0, 'sparsity_level': 0.05, 'exclusive_regularizer': 1.0, 'corrupt_prob': 1.0, 'tied_weight': True, 'exclusive_type': 'logcosh', 'exclusive_scale': 10.0, # 'gaussian_mean': 0.0, # 'gaussian_std': 0.0, 'encode': 'sigmoid', 'decode': 'linear', 'pathways': [ range(0, 150), range(75, 225), ], }, ] xae = eXclusiveAutoencoder( input_dimensions=lymphocyte_data.shape[1], layers=xae_layers, init_encoder_weight=None, init_decoder_weight=None, init_encoder_bias=None, init_decoder_bias=None, ) fcn_dimensions = [225, 45, 9, 2] fcn = FullyConnectedNetwork( dimensions=fcn_dimensions, init_weight=None, init_bias=None, ) xae_optimizer_list = [] for layer_i in range(len(xae_layers)): xae_optimizer_list.append( tf.train.AdamOptimizer(xae_learning_rate).minimize( xae['layerwise_cost'][layer_i]['total'], var_list=[ xae['encoder_weight'][layer_i], xae['encoder_bias'][layer_i], # xae['decoder_weight'][layer_i], # xae['decoder_bias'][layer_i], ])) xae_optimizer_full = tf.train.AdamOptimizer(xae_learning_rate).minimize( xae['cost']['total']) fcn_optimizer = tf.train.AdamOptimizer(fcn_learning_rate).minimize( fcn['cost']) # fcn_optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9).minimize(fcn['cost']) # fcn_optimizer = tf.train.AdamOptimizer(learning_rate).minimize(fc['cost']) # correct_prediction = tf.equal(tf.argmax(fcn['y'], 1), tf.argmax(fcn['y_'], 1)) # accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # %% # We create a session to use the graph sess = tf.Session() writer = tf.summary.FileWriter('logs', sess.graph) sess.run(tf.global_variables_initializer()) # %% # Fit all training data for layer_i in range(len(xae_layers)): for epoch_i in range(n_xae_epochs): if (epoch_i) % n_xae_reload_per_epochs == 0: batch_xs, batch_ys = lymphocyte_training_dataset[random.sample( range(lymphocyte_training_dataset.__len__()), n_xae_batch_size)] train = [] train.append( np.array([ img - mean for img in batch_xs[np.where( np.any( np.array([ batch_ys[:, 0], # batch_ys[:, 1], ]) == 1, axis=0))] ])) train.append( np.array([ img - mean for img in batch_xs[np.where( np.any( np.array([ # batch_ys[:, 0], batch_ys[:, 1], ]) == 1, axis=0))] ])) sess.run(xae_optimizer_list[layer_i], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) if (epoch_i + 1) % n_xae_display_per_epochs == 0: cost_total = sess.run(xae['layerwise_cost'][layer_i]['total'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_reconstruction_error = sess.run( xae['layerwise_cost'][layer_i]['reconstruction_error'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_sparsity = sess.run( xae['layerwise_cost'][layer_i]['sparsity'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_exclusivity = sess.run( xae['layerwise_cost'][layer_i]['exclusivity'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_weight_decay = sess.run( xae['layerwise_cost'][layer_i]['weight_decay'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) print('layer:', layer_i + 1, ', epoch:', epoch_i + 1, ', total cost:', cost_total, ', recon error:', cost_reconstruction_error, ', sparsity:', cost_sparsity, ', weight decay:', cost_weight_decay, ', exclusivity: ', cost_exclusivity) test_xs, test_ys = lymphocyte_training_dataset[random.sample( range(lymphocyte_training_dataset.__len__()), 10240)] test_xs_0 = np.array([ img - mean for img in test_xs[np.where( np.any( np.array([ test_ys[:, 0], # test_ys[:, 1], ]) == 1, axis=0))][:225] ]) recon_0 = sess.run(xae['layerwise_y'][layer_i], feed_dict={xae['x']: test_xs_0}) test_xs_1 = np.array([ img - mean for img in test_xs[np.where( np.any( np.array([ # test_ys[:, 0], test_ys[:, 1], ]) == 1, axis=0))][:225] ]) recon_1 = sess.run(xae['layerwise_y'][layer_i], feed_dict={xae['x']: test_xs_1}) weights = sess.run(xae['encoder_weight'][0]) display_color_network(weights, filename='lymphocyte_weights.png') display_color_network(test_xs_0.transpose(), filename='lymphocyte_test_0.png') display_color_network(recon_0.transpose(), filename='lymphocyte_results_0.png') display_color_network(test_xs_1.transpose(), filename='lymphocyte_test_1.png') display_color_network(recon_1.transpose(), filename='lymphocyte_results_1.png') for epoch_i in range(n_xae_epochs): if (epoch_i) % n_xae_reload_per_epochs == 0: batch_xs, batch_ys = lymphocyte_training_dataset[random.sample( range(lymphocyte_training_dataset.__len__()), n_xae_batch_size)] train = [] train.append( np.array([ img - mean for img in batch_xs[np.where( np.any( np.array([ batch_ys[:, 0], # batch_ys[:, 1], ]) == 1, axis=0))] ])) train.append( np.array([ img - mean for img in batch_xs[np.where( np.any( np.array([ # batch_ys[:, 0], batch_ys[:, 1], ]) == 1, axis=0))] ])) sess.run(xae_optimizer_full, feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) if (epoch_i + 1) % n_xae_display_per_epochs == 0: cost_total = sess.run(xae['cost']['total'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_reconstruction_error = sess.run( xae['cost']['reconstruction_error'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_sparsity = sess.run(xae['cost']['sparsity'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_exclusivity = sess.run(xae['cost']['exclusivity'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) cost_weight_decay = sess.run(xae['cost']['weight_decay'], feed_dict={ xae['training_x'][0]: train[0], xae['training_x'][1]: train[1] }) print('layer: full,', 'epoch:', epoch_i + 1, ', total cost:', cost_total, ', recon error:', cost_reconstruction_error, ', sparsity:', cost_sparsity, ', weight decay:', cost_weight_decay, ', exclusivity: ', cost_exclusivity) test_xs, test_ys = lymphocyte_training_dataset[random.sample( range(lymphocyte_training_dataset.__len__()), 10240)] test_xs_0 = np.array([ img - mean for img in test_xs[np.where( np.any( np.array([ test_ys[:, 0], # test_ys[:, 1], ]) == 1, axis=0))][:225] ]) test_xs_1 = np.array([ img - mean for img in test_xs[np.where( np.any( np.array([ # test_ys[:, 0], test_ys[:, 1], ]) == 1, axis=0))][:225] ]) recon_0 = sess.run(xae['y'], feed_dict={xae['x']: test_xs_0}) recon_1 = sess.run(xae['y'], feed_dict={xae['x']: test_xs_1}) weights = sess.run(xae['encoder_weight'][0]) display_color_network(weights, filename='lymphocyte_weights.png') display_color_network(test_xs_0.transpose(), filename='lymphocyte_test_0.png') display_color_network(recon_0.transpose(), filename='lymphocyte_results_0.png') display_color_network(test_xs_1.transpose(), filename='lymphocyte_test_1.png') display_color_network(recon_1.transpose(), filename='lymphocyte_results_1.png') for epoch_i in range(n_fcn_epochs): if (epoch_i) % n_fcn_reload_per_epochs == 0: batch_xs, batch_ys = lymphocyte_training_dataset[random.sample( range(lymphocyte_training_dataset.__len__()), n_fcn_batch_size)] ae_z = sess.run(xae['z'], feed_dict={xae['x']: batch_xs}) sess.run(fcn_optimizer, feed_dict={ fcn['x']: ae_z, fcn['y_']: batch_ys, fcn['keep_prob_input']: 0.9, fcn['keep_prob']: 0.9 }) if (epoch_i + 1) % n_fcn_display_per_epochs == 0: cost = sess.run(fcn['cost'], feed_dict={ fcn['x']: ae_z, fcn['y_']: batch_ys, fcn['keep_prob_input']: 1.0, fcn['keep_prob']: 1.0 }) test_xs, test_ys = lymphocyte_test_dataset[random.sample( range(lymphocyte_test_dataset.__len__()), n_fcn_batch_size)] ae_z = sess.run(xae['z'], feed_dict={xae['x']: test_xs}) acc = sess.run(fcn['accuracy'], feed_dict={ fcn['x']: ae_z, fcn['y_']: test_ys, fcn['keep_prob_input']: 1.0, fcn['keep_prob']: 1.0 }) print('epoch:', epoch_i + 1, ', cost:', cost, ', accuracy:', acc) test_xs, test_ys = lymphocyte_test_dataset[:] ae_z = sess.run(xae['z'], feed_dict={xae['x']: test_xs}) y = sess.run(fcn['y'], feed_dict={ fcn['x']: ae_z, fcn['y_']: test_ys, fcn['keep_prob_input']: 1.0, fcn['keep_prob']: 1.0 }) prediction = sess.run(fcn['prediction'], feed_dict={ fcn['x']: ae_z, fcn['y_']: test_ys, fcn['keep_prob_input']: 1.0, fcn['keep_prob']: 1.0 }) conf_matrix = confusion_matrix(test_ys[:, 1], prediction) num_labels = 2 print('final f1_score:', f1_score(test_ys[:, 1], prediction, average="macro")) print('final precision:', precision_score(test_ys[:, 1], prediction, average="macro")) print('final recall:', recall_score(test_ys[:, 1], prediction, average="macro")) print('final average_precision:', average_precision_score(test_ys[:, 1], prediction, average="macro")) print( 'final accuracy:', sess.run(fcn['accuracy'], feed_dict={ fcn['x']: ae_z, fcn['y_']: test_ys, fcn['keep_prob_input']: 1.0, fcn['keep_prob']: 1.0 })) sys.stdout.write('\n\nConfusion Matrix') sys.stdout.write('\t' * (num_labels - 2) + '| Accuracy') sys.stdout.write('\n' + '-' * 8 * (num_labels + 1)) sys.stdout.write('\n') for i in range(len(conf_matrix)): for j in range(len(conf_matrix[i])): sys.stdout.write(str(conf_matrix[i][j].astype(np.int)) + '\t') sys.stdout.write('| %3.2f %%' % (conf_matrix[i][i] * 100 / conf_matrix[i].sum())) sys.stdout.write('\n') sys.stdout.write('Number of test samples: %i \n\n' % conf_matrix.sum()) # Compute ROC curve and ROC area for each class fpr, tpr, _ = roc_curve(test_ys[:, 1], y[:, 1]) roc_auc = auc(fpr, tpr) # Compute micro-average ROC curve and ROC area fpr_micro, tpr_micro, _ = roc_curve(test_ys.ravel(), y.ravel()) roc_auc_micro = auc(fpr, tpr) # Plot of a ROC curve for a specific class plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.3f)' % roc_auc) plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--') plt.xlim([-0.01, 1.0]) plt.ylim([0.0, 1.01]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver Operating Characteristic (ROC) Curve') plt.legend(loc="lower right") plt.gcf().savefig('lymphocyte_rocplot.png') plt.clf() writer.close() xae_encoder_weight = sess.run(xae['encoder_weight']) xae_encoder_bias = sess.run(xae['encoder_bias']) xae_decoder_weight = sess.run(xae['decoder_weight']) xae_decoder_bias = sess.run(xae['decoder_bias']) fcn_weight = sess.run(fcn['weight']) fcn_bias = sess.run(fcn['bias']) data = { 'xae_layers': xae_layers, 'fcn_dimensions': fcn_dimensions, 'xae_encoder_weight': xae_encoder_weight, 'xae_encoder_bias': xae_encoder_bias, 'xae_decoder_weight': xae_decoder_weight, 'xae_decoder_bias': xae_decoder_bias, 'fcn_weight': fcn_weight, 'fcn_bias': fcn_bias, 'mean': mean, 'patch_size': PATCH_SIZE, } with open(output_file, 'wb') as fp: pickle.dump(data, fp, protocol=pickle.HIGHEST_PROTOCOL)
""" # Loading the learned features and preprocessing matrices load_data = joblib.load("data/STL10_features.pkl") opt_theta = load_data['opt_theta'] zca_white = load_data['zca_white'] mean_patch = load_data['mean_patch'] W = opt_theta[0:visible_size * hidden_size].reshape( (hidden_size, visible_size)) b = opt_theta[2 * hidden_size * visible_size:2 * hidden_size * visible_size + hidden_size] # Display and check to see that the features look good image = display_color_network((W.dot(zca_white)).T) plt.imsave('cnn_learned_features.png', image) plt.imshow(image) """ STEP 2: Implement and test convolution and pooling In this step, you will implement convolution and pooling, and test them on a small part of the data set to ensure that you have implemented these two functions correctly. In the next step, you will actually convolve and pool the features with the STL10 images. """ """ STEP 2a: Implement convolution Implement convolution in the function cnnConvolve in cnnConvolve.m """ # Note that we have to preprocess the images in the exact same way # we preprocessed the patches before we can obtain the feature activations.