def main(): # Load dataset train_x, train_y = mnist.load_dataset(download=True, train=True) test_x, test_y = mnist.load_dataset(download=True, train=False) # Batch Gradient Descent print("Training using Batch Gradient Descent") w1_bgd, b1_bgd, w2_bgd, b2_bgd, loss_history_bgd = train(train_x, train_y, learning_rate=0.2, num_epochs=20, batch_size=None) # Minibatch Gradient Descent with batch_size 64 print("Training using mini-Batch Gradient Descent with batch size of 64") w1_mbgd, b1_mbgd, w2_mbgd, b2_mbgd, loss_history_mbgd = train( train_x, train_y, learning_rate=0.1, num_epochs=20, batch_size=64) # Display loss curve plt.plot(loss_history_bgd, label="Batch Gradient Descent") plt.plot(loss_history_mbgd, label="mini-Batch Gradient Descent") plt.legend() plt.show() # Test print("Batch Gradient Descent") test(test_x, test_y, w1_bgd, b1_bgd, w2_bgd, b2_bgd) print("mini-Batch Gradient Descent") test(test_x, test_y, w1_mbgd, b1_mbgd, w2_mbgd, b2_mbgd)
def main(argv): options = handle_options('set', argv) mnist_data = load_dataset() X_train = mnist_data[0].reshape(-1, 28, 28, 1) sfx = gen_sfx_key(('adt', 'nblocks', 'block_size'), options) empty_set_args = {'initializer': tf.random_uniform_initializer} set_adt, set_pdt = gen_set_adt(X_train, options, store_args=options, is_in_args=options, size_args=options, is_empty_args=options, empty_set_args=empty_set_args, nitems=options['nitems'], batch_size=options['batch_size']) graph = tf.get_default_graph() savedir = mk_dir(sfx) path_name = os.path.join( os.environ['DATADIR'], 'graphs', sfx, ) tf.train.SummaryWriter(path_name, graph) load_train_save(options, set_adt, set_pdt, sfx, savedir) push, pop = pdt.call_fns
def NerNet(batchsize = 50, epochs = 10): def Ner(X_inputs, y_targets, batch_size = 50, num_epochs = 10): input_X = T.tensor4('Input') target_y = T.vector('Target', dtype='int32') input_layer = lasagne.layers.InputLayer(shape=(None,1,28,28), input_var=input_X, name = "Input") dense_layer = lasagne.layers.DenseLayer(input_layer,num_units=100, nonlinearity=sigmoid, name = "Dense") output_layer = lasagne.layers.DenseLayer(dense_layer,num_units = 10, nonlinearity=softmax, name = "Output") y_predicted = lasagne.layers.get_output(output_layer) all_weights = lasagne.layers.get_all_params(output_layer) loss = lasagne.objectives.categorical_crossentropy(y_predicted,target_y).mean() accuracy = lasagne.objectives.categorical_accuracy(y_predicted,target_y).mean() updates_sgd = lasagne.updates.rmsprop(loss, all_weights,learning_rate=0.01) train_fun = theano.function([input_X,target_y],[loss,accuracy],updates= updates_sgd) accuracy_fun = theano.function([input_X,target_y],accuracy) pred_fun = theano.function([input_X], y_predicted) for epoch in range(num_epochs): # In each epoch, we do a full pass over the training data: train_err = 0 train_acc = 0 train_batches = 0 start_time = time.time() for batch in iterate_minibatches(X_inputs, y_targets, batch_size): inputs, targets = batch train_err_batch, train_acc_batch= train_fun(inputs, targets) train_err += train_err_batch train_acc += train_acc_batch train_batches += 1 # And a full pass over the validation data: val_acc = 0 val_batches = 0 for batch in iterate_minibatches(X_val, y_val, batch_size): inputs, targets = batch val_acc += accuracy_fun(inputs, targets) val_batches += 1 # Then we print the results for this epoch: print("Epoch {} of {} took {:.3f}s".format( epoch + 1, num_epochs, time.time() - start_time)) print(" training loss (in-iteration):\t\t{:.6f}".format(train_err / train_batches)) print(" train accuracy:\t\t{:.2f} %".format( train_acc / train_batches * 100)) print(" validation accuracy:\t\t{:.2f} %".format( val_acc / val_batches * 100)) return pred_fun, accuracy_fun X_train,y_train,X_val,y_val,X_test,y_test = load_dataset() return Ner(X_train, y_train, batch_size = batchsize, num_epochs = epochs)
def init_data(self): X_train, y_train, X_val, y_val, X_test, y_test = load_dataset() self.train_X = X_train self.train_y = y_train self.test_X = X_test self.test_y = y_test self.val_X = X_val self.val_y = y_val
def main(): # Load dataset train_x, train_y = mnist.load_dataset(download=True, train=True) test_x, test_y = mnist.load_dataset(download=True, train=False) # Train w1, b1, w2, b2, loss_history = train(train_x, train_y) # Display loss curve plt.plot(loss_history, label="Training Loss") plt.show() # Test test(test_x, test_y, w1, b1, w2, b2) # A little visualization visualization(test_x, test_y, w1, b1, w2, b2) plt.show()
def train_model(config: Union[ str, AsciiLetterConfig] = AsciiLetterConfig()) -> None: """Train the model and save classifier and feature weights.""" if isinstance(config, str): config = AsciiLetterConfig.from_yaml(config) files = AsciiLetterFiles(config) x_train, y_train = load_dataset(files.train_dataset, config) x_test, y_test = load_dataset(files.test_dataset, config) model = ascii_letter_classifier(config) model.fit( x_train, y_train, validation_data=(x_test, y_test), verbose=config.verbose, epochs=config.n_epochs, steps_per_epoch=config.steps_per_epoch, validation_steps=config.validation_steps, ) model.save_weights(files.model_weights, overwrite=True) return 'OK'
def get_base_data(half_n_samples, alpha0=0): X_train, y_train, X_val, y_val, X_test, y_test = load_dataset() all_data = np.vstack((X_train, X_val, X_test)) all_data = all_data.reshape(-1, 28, 28) subsample_indices = np.random.choice(len(all_data), half_n_samples, replace=False) all_data = all_data[subsample_indices] if alpha0 != 0: all_data = rotate_dataset(all_data, alpha0) return all_data
def main(argv): global queue_adt, queue_pdt, sess, X_train, sfx options = handle_options('queue', argv) mnist_data = load_dataset() X_train = mnist_data[0].reshape(-1, 28, 28, 1) sfx = gen_sfx_key(('adt', 'nblocks', 'block_size'), options) empty_queue_args = {'initializer': tf.random_uniform_initializer} queue_adt, queue_pdt = gen_queue_adt(X_train, options, enqueue_args=options, nitems=options['nitems'], dequeue_args=options, empty_queue_args=empty_queue_args, batch_size=options['batch_size']) savedir = mk_dir(sfx) sess = load_train_save(options, queue_adt, queue_pdt, sfx, savedir)
# Parse the arguments and perform some clean up dropping out the None values args = {k: v for k, v in vars(parser.parse_args()).iteritems() if v} print(args) ################################################################ def iterate_minibatches(inputs, targets, batchsize): p = np.random.permutation(inputs.shape[0]) for idx in range(0, inputs.shape[0] - batchsize + 1, batchsize): yield (inputs[p])[idx:idx + batchsize], (targets[p])[idx:idx + batchsize] print("Loading the data") X_train, y_train, X_test, y_test = mnist.load_dataset(args['nbtrain'], args['nbtest'], False) ############################################################################ # Model building print("Model architecture : ") filename_prefix = "" if ('logreg' in args): print(" Logistic regression, Input -> Softmax") model = LogisticRegression.Model(28, 28, 1, 10) filename_prefix += "logreg_" elif 'mlp' in args: print(" Multilayer perceptron with : ") filename_prefix += "mlp_" sys.exit() elif 'cnn' in args:
return F.softmax_cross_entropy(y, t) def accuracy(self, x, t): y = self.predict(x) accuracy = F.accuracy(y, t) return accuracy def gradient(self, x, t): loss = self.loss(x, t) self.net.cleargrads() loss.backward() return loss.grad if __name__ == "__main__": dataset = mnist.load_dataset() x_train = dataset['train_img'] t_train = dataset['train_label'] x_test = dataset['test_img'] t_test = dataset['test_label'] network = TwoLayerNet(784, 50, 10) iters_num = 10000 train_size = x_train.shape[0] batch_size = 100 learning_rate = 0.1 optimizer = chainer.optimizers.SGD(lr=learning_rate)
# Then we print the results for this epoch: print("for {}".format(res_name)) print("Epoch {} of {} took {:.3f}s".format( epoch + 1, num_epochs, time.time() - start_time)) print(" training loss (in-iteration):\t\t{:.6f}".format( train_err / train_batches)) print(" train accuracy:\t\t{:.2f} %".format(train_acc / train_batches * 100)) print(" validation accuracy:\t\t{:.2f} %".format( val_acc / val_batches * 100)) res["train_err"].append(train_err / train_batches) res["train_acc"].append(train_acc / train_batches * 100) res["val_acc"].append(val_acc / val_batches * 100) # Just profile if you need pr.disable() pr.print_stats(sort='cumtime') for res in results.values(): res.pop('train_fun') res.pop('accuracy_fun') with open("comparative_history.dict", 'wb') as pickle_file: pickle.dump(results, pickle_file) if __name__ == "__main__": from mnist import load_dataset X_train, y_train, X_val, y_val, X_test, y_test = load_dataset() print(X_train.shape, y_train.shape) run(X_train, y_train, X_val, y_val, X_test, y_test)
import os import sys import numpy as np from neuralnetwork.network import load_from_file from mnist import load_dataset, result_to_digit logging.basicConfig(level=logging.INFO) logger = logging.getLogger("digits_recognizer") with open("digits_recognizer_setup.txt", "r") as f: neural_network = load_from_file(f) logger.info("Testing") logger.info("Loading testing dateset") testing_data = load_dataset('./datasets/mnist/mnist_test.csv') logger.info("Testing dateset loaded") logger.info("Testing network") good = 0 bad = 0 case_index = 0 for sample in testing_data: result = neural_network.feedforward(sample.input) expected_result = result_to_digit(sample.output) actual_result = result_to_digit(result) print("Case %d: %d %d %d" % (case_index, actual_result, expected_result, actual_result == expected_result)) if actual_result == expected_result: good += 1 else:
pad='same', stride=(1, 1)) n_params += lasagne.layers.count_params(l_prev) l_prev = lasagne.layers.ConcatLayer([l_unit, l_prev]) l_prev = lasagne.layers.NonlinearityLayer( l_prev, nonlinearity=lasagne.nonlinearities.rectify) l_out = lasagne.layers.DenseLayer( l_prev, num_units=10, nonlinearity=lasagne.nonlinearities.softmax) n_params += lasagne.layers.count_params(l_out) print("%i parameters to find." % n_params) return input_var, l_out print("Loading the data") X_train, y_train, X_test, y_test = mnist.load_dataset(nb_training_samples, nb_test_samples, False) print("Building the model") input_var, model = build_model((16, )) prediction = lasagne.layers.get_output(model) # Define the Negative Log Likelihood loss target_var = T.ivector('targets') loss = lasagne.objectives.categorical_crossentropy(prediction, target_var) loss = loss.mean() l2 = lasagne.regularization.regularize_network_params( model, lasagne.regularization.l2) loss += weight_decay * l2 # Define the update of the weights
l_unit = lasagne.layers.NonlinearityLayer(l_prev, nonlinearity=lasagne.nonlinearities.identity) l_prev = lasagne.layers.Conv2DLayer(l_prev, k, 3, nonlinearity=lasagne.nonlinearities.rectify, pad='same', stride=(1,1)) n_params += lasagne.layers.count_params(l_prev) l_prev = lasagne.layers.Conv2DLayer(l_prev, k, 3, nonlinearity=lasagne.nonlinearities.identity, pad='same', stride=(1,1)) n_params += lasagne.layers.count_params(l_prev) l_prev = lasagne.layers.ConcatLayer([l_unit, l_prev]) l_prev = lasagne.layers.NonlinearityLayer(l_prev, nonlinearity=lasagne.nonlinearities.rectify) l_out = lasagne.layers.DenseLayer(l_prev, num_units=10, nonlinearity=lasagne.nonlinearities.softmax) n_params += lasagne.layers.count_params(l_out) print("%i parameters to find."% n_params) return input_var, l_out print("Loading the data") X_train, y_train, X_test, y_test = mnist.load_dataset(nb_training_samples, nb_test_samples, False) print("Building the model") input_var, model = build_model((16,)) prediction = lasagne.layers.get_output(model) # Define the Negative Log Likelihood loss target_var = T.ivector('targets') loss = lasagne.objectives.categorical_crossentropy(prediction, target_var) loss = loss.mean() l2 = lasagne.regularization.regularize_network_params(model, lasagne.regularization.l2) loss += weight_decay * l2 # Define the update of the weights params = lasagne.layers.get_all_params(model, trainable=True)
def main_new(num_epochs=500, num_train=0, use_existing=False, rotate_angle=0): # Load the dataset batch_size=100 thresh=.9 eta_init=np.float32(.001) print("Loading data...") X_train_in, y_train_in, X_val_in, y_val_in, X_test_in, y_test_in = mnist.load_dataset() if (rotate_angle>0): X_train_in=mnist.rotate_dataset(X_train_in,angle=rotate_angle) X_val_in=mnist.rotate_dataset(X_val_in,angle=rotate_angle) X_test_in=mnist.rotate_dataset(X_test_in,angle=rotate_angle) if (num_train==0): num_train=np.shape(y_train_in)[0] #X_train_r=rotate_dataset(X_train,12,num_train) #X_val_r=rotate_dataset(X_val,12,np.shape(X_val)[0]) X_train, X_train_c, y_train=compare_net.create_paired_data_set(X_train_in, y_train_in, num_train) X_val, X_val_c, y_val = compare_net.create_paired_data_set(X_val_in, y_val_in, num_train) X_test, X_test_c, y_test = compare_net.create_paired_data_set(X_test_in, y_test_in, num_train) X_test1, X_test_f, y_test_f, y_label = compare_net.create_paired_data_set_with_fonts(X_test_in, y_test_in, 10000) # Prepare Theano variables for inputs and targets input_var1 = T.tensor4('inputs') input_var2 = T.tensor4('inputs_comp') target_var = T.fvector('target') # Create neural network model (depending on first command line parameter) print("Building model and compiling functions...") network = compare_net.build_cnn_new_conv(input_var1, input_var2) if (os.path.isfile('net.npy') and use_existing): spars=np.load('net.npy') lasagne.layers.set_all_param_values(network,spars) #layers=lasagne.layers.get_all_layers(network) # Create a loss expression for training, i.e., a scalar objective we want # to minimize (for our multi-class problem, it is the cross-entropy loss): corr = lasagne.layers.get_output(network) corr=correlation(corr[0,],corr[1,]) #loss=T.mean(T.square(T.sum(corr,axis=1)-target_var)) loss=T.mean(T.square(corr-target_var)) acc = T.mean(T.eq(corr>thresh, target_var), dtype=theano.config.floatX) # We could add some weight decay as well here, see lasagne.regularization. # Create update expressions for training, i.e., how to modify the # parameters at each training step. Here, we'll use Stochastic Gradient # Descent (SGD) with Nesterov momentum, but Lasagne offers plenty more. params = lasagne.layers.get_all_params(network, trainable=True) print(params) eta = theano.shared(np.array(eta_init, dtype=theano.config.floatX)) #eta_decay = np.array(0.95, dtype=theano.config.floatX) updates = lasagne.updates.nesterov_momentum( loss, params, learning_rate=eta, momentum=0.9) #updates = lasagne.updates.sgd( # loss, params, learning_rate=eta) # Create a loss expression for validation/testing. The crucial difference # here is that we do a deterministic forward pass through the network, # disabling dropout layers. test_corr = lasagne.layers.get_output(network, deterministic=True) test_corr=correlation(test_corr[0,], test_corr[1,]) #test_loss=T.mean(T.square(T.sum(test_corr,axis=1)-target_var)) test_loss=T.mean(T.square(test_corr-target_var)) # As a bonus, also create an expression for the classification accuracy: test_acc = T.mean(T.eq(test_corr>thresh, target_var), dtype=theano.config.floatX) # Compile a function performing a training step on a mini-batch (by giving # the updates dictionary) and returning the corresponding training loss: train_fn = theano.function([input_var1, input_var2, target_var], [loss, acc, corr], updates=updates) # Compile a second function computing the validation loss and accuracy: val_fn = theano.function([input_var1, input_var2, target_var], [test_loss, test_acc, test_corr]) # Finally, launch the training loop. print("Starting training...") # We iterate over epochs: t=1 for epoch in range(num_epochs): # In each epoch, we do a full pass over the training data: train_err = 0 train_acc = 0 train_batches = 0 start_time = time.time() print(eta.get_value()) for batch in iterate_minibatches_new(X_train,X_train_c, y_train, batch_size, shuffle=True): inputs1, inputs2, targets = batch eta.set_value(eta_init) #/np.float32(t)) bloss, bacc, bcorr = train_fn(inputs1,inputs2,targets) train_err += bloss train_acc += bacc train_batches += 1 t=t+1 # And a full pass over the validation data: val_acc=0 val_err = 0 val_batches = 0 for batch in iterate_minibatches_new(X_val,X_val_c, y_val, batch_size, shuffle=False): inputs1, inputs2, targets = batch err, acc, tcorr = val_fn(inputs1, inputs2, targets) val_err += err val_acc += acc val_batches += 1 # Then we print the results for this epoch: print("Epoch {} of {} took {:.3f}s".format( epoch + 1, num_epochs, time.time() - start_time)) print(" training loss:\t\t{:.6f}".format(train_err / train_batches)) print(" train accuracy:\t\t{:.6f}".format(train_acc/ train_batches)) print(" validation loss:\t\t{:.6f}".format(val_err / val_batches)) print(" validation accuracy:\t\t{:.6f}".format(val_acc/ val_batches)) if (np.mod(epoch,10)==0 and epoch>0): params = lasagne.layers.get_all_param_values(network) np.save('net',params) # After training, we compute and print the test error: test_err = 0 test_acc = 0 test_batches = 0 for batch in iterate_minibatches_new(X_test, X_test_c, y_test, batch_size, shuffle=False): inputs1, inputs2, targets = batch err, acc, tcorr = val_fn(inputs1, inputs2, targets) test_acc += acc test_err += err test_batches += 1 print("Final results:") print(" test loss:\t\t\t{:.6f}".format(test_err / test_batches)) print(" test acc:\t\t\t{:.6f}".format(test_acc / test_batches)) try: X_test1 except NameError: print "X_test1 not defined" else: test_err = 0 test_acc = 0 test_batches = 0 corrs=[] for batch in iterate_minibatches_new(X_test1, X_test_f, y_test_f, batch_size, shuffle=False): inputs1, inputs2, targets = batch err, acc, tcorr = val_fn(inputs1, inputs2, targets) corrs.append(np.reshape(tcorr,(10,-1))) test_acc += acc test_err += err test_batches += 1 CORRS=np.vstack(corrs) yii=np.argmax(CORRS,axis=1) print("Final results classification:") print(" test loss font:\t\t\t{:.6f}".format(test_err / test_batches)) print(" test acc font:\t\t\t{:.6f}".format(np.double(np.sum(yii==y_label)) / len(yii)))
parser.add_argument('--epoch', type=int, help='Number of training epochs', default=80) # Parse the arguments and perform some clean up dropping out the None values args = {k:v for k, v in vars(parser.parse_args()).iteritems() if v} print(args) ################################################################ def iterate_minibatches(inputs, targets, batchsize): p = np.random.permutation(inputs.shape[0]) for idx in range(0, inputs.shape[0] - batchsize + 1, batchsize): yield (inputs[p])[idx:idx+batchsize],(targets[p])[idx:idx+batchsize] print("Loading the data") X_train, y_train, X_test, y_test = mnist.load_dataset(args['nbtrain'], args['nbtest'], False) ############################################################################ # Model building print("Model architecture : ") if('logreg' in args): print(" Logistic regression, Input -> Softmax") model = LogisticRegression.Model(28, 28, 1, 10) elif 'mpl' in args: print(" Multilayer perceptron with : ") sys.exit() elif 'cnn' in args: print(" Convolutional neural network with :") sys.exit() elif 'vgg' in args:
import numpy as np from neuralnetwork.network import NeuralNetwork, serialize_neural_network from neuralnetwork.training import Trainer from mnist import load_dataset logging.basicConfig(level=logging.INFO) logger = logging.getLogger("digits_recognizer") # Create neural network neural_network = NeuralNetwork([784, 20, 10]) # # Train the network logger.info("Begining training") logger.info("Loading training dateset") training_data = load_dataset('./datasets/mnist/mnist_train.csv') logger.info("Training dateset loaded") logger.info("Training network") trainer = Trainer() trainer.train(network=neural_network, training_data=training_data, learning_step=1, batch_iterations=20, batch_size=50, min_improvement_per_batch=0.000001, max_batches_without_improvement=100, cost_estimator_batch_size=5000) logger.info("Network has been trained") logger.info("Serializing network setup to digits_recognizer_setup.txt")
np.random.shuffle(indices) for start in range(0, n_samples, batchsize): end = min(start + batchsize, n_samples) batch_idx = indices[start:end] yield X[batch_idx], y[batch_idx] if n_samples % batchsize != 0: batch_idx = indices[n_samples - n_samples % batchsize :] yield X[batch_idx], y[batch_idx] if __name__ == "__main__": from mnist import load_dataset X_train,y_train,X_val,y_val,X_test,y_test = load_dataset() print(X_train.shape,y_train.shape) input_X = T.tensor4("X") input_shape = [None,1,28,28] target_y = T.vector("target Y integer", dtype='int32') #входной слой (вспомогательный) input_layer = lasagne.layers.InputLayer(shape = input_shape,input_var=input_X) #полносвязный слой, который принимает на вход input layer и имеет 100 нейронов. # нелинейная функция - сигмоида как в логистической регрессии # слоям тоже можно давать имена, но это необязательно dense_1 = DotLayer(input_layer, num_units=10, name = "output")
def make_seqs(slength=2, num_seqs=20, from_font=False): #def make_seqs(slength=4): imheight=48 imwidth=48 print("Loading data...") X_train, y_train, X_val, y_val, X_test, y_test = mnist.load_dataset() if (from_font): Xfont=crop.get_fonts() begin=0 incr=30 lrange=3 lrange2=lrange*2+1 labels=np.floor(np.random.rand(num_seqs,slength,2)*10) TEST1=[] TEST1a=[] TEST2=[] for s in range(num_seqs): begin1=begin1a=begin2=np.int32(0) ii1=labels[s,:,0] ii2=labels[s,:,1] test1=np.zeros((imheight,imwidth*slength)) test1a=np.zeros((imheight,imwidth*slength)) test2=np.zeros((imheight,imwidth*slength)) if (np.max(np.abs(ii1-ii2))>0): for k in range(slength): jj1=np.where(y_val==ii1[k])[0] jj2=np.where(y_val==ii2[k])[0] r1s=np.int32(np.floor(np.random.rand(2)*np.double(len(jj1)))) r2=np.int32(np.floor(np.random.rand()*np.double(len(jj2)))) sample1=scipy.misc.imresize(np.squeeze(X_val[jj1[r1s[0]],]),(imheight,imwidth)) if (not from_font): sample1a=np.squeeze(X_val[jj1[r1s[1]],]) else: sample1a=Xfont[np.int32(ii1[k]),] sample2=np.squeeze(X_val[jj2[r2],]) sample1a=scipy.misc.imresize(sample1a,(imheight,imwidth)) sample2=scipy.misc.imresize(sample2,(imheight,imwidth)) test1[:,begin1:begin1+sample1.shape[1]]=np.maximum(sample1,test1[:,begin1:begin1+sample1.shape[1]]) test1a[:,begin1a:begin1a+sample1.shape[1]]=np.maximum(sample1a,test1a[:,begin1a:begin1a+sample1.shape[1]]) test2[:,begin2:begin2+sample1.shape[1]]=np.maximum(sample2,test2[:,begin2:begin2+sample1.shape[1]]) begin1+=np.int32(np.floor(np.random.rand()*lrange2)-lrange+incr) begin1a+=np.int32(np.floor(np.random.rand()*lrange2)-lrange+incr) begin2+=np.int32(np.floor(np.random.rand()*lrange2)-lrange+incr) TEST1.append(test1) TEST1a.append(test1a) TEST2.append(test2) import pylab as py ii=range(num_seqs) np.random.shuffle(ii) for i in range(5): py.figure(num=1,figsize=(12,2),dpi=80) py.subplot(131) py.imshow(TEST1[ii[i]],aspect='equal') py.axis('off') py.subplot(132) py.imshow(TEST1a[ii[i]],aspect='equal') py.axis('off') py.subplot(133) py.imshow(TEST2[ii[i]],aspect='equal') py.axis('off') py.show() TEST1=np.float32(np.expand_dims(np.array(TEST1),1)) TEST1a=np.float32(np.expand_dims(np.array(TEST1a),1)) TEST2=np.float32(np.expand_dims(np.array(TEST2),1)) return TEST1,TEST1a, TEST2