def FeedForward_UnitTest(): featureSize = 12 colorChannels = 1 # Load Centroids and Initialize KMean module centroids = datamanipulation.LoadCentroids("C:/Images/TempCentroids_" + str(colorChannels) + ".txt") KMean = kmean.KMean(featureSize * featureSize * colorChannels, len(centroids)) # Load image and slice it image_a = datamanipulation.LoadImageData(["C:/Images/Satellite_1.png"], colorChannels) image_b = datamanipulation.LoadImageData(["C:/Images/Satellite_1_LQ.png"], colorChannels) compare_1 = datamanipulation.CompareImages(image_a, image_a) compare_2 = datamanipulation.CompareImages(image_a, image_b) data = datamanipulation.SliceImage(image_b, featureSize * colorChannels, featureSize) loadedPoints = len(data) # Classify points data = KMean.KmeanClassification(data, centroids) # Sort points by centroid classifiedPoints = 0 for centroid in range(0, len(centroids)): points = [x for x in data if x[-3] == centroid] classifiedPoints = classifiedPoints + len(points) encoder = autoencoder.AutoEncoder([ featureSize * featureSize * colorChannels, 100, featureSize * featureSize * colorChannels ]) if (encoder.LoadParameters("C:/Images/EncoderParameters_" + str(colorChannels) + "_" + str(centroid) + ".txt")): print("feeding points into encoder") for point in points: output = encoder.FeedForward( np.array(point[:-3]).reshape(144, 1)) image_b = datamanipulation.InsertSubImage( image_b, output.flatten(), featureSize, colorChannels, point[-2], point[-1], referenceImage=image_a) else: print("unable to load encoder") # return False compare_3 = datamanipulation.CompareImages(image_a, image_b) print("Compare 1: " + str(compare_1)) print("Compare 2: " + str(compare_2)) print("Compare 3: " + str(compare_3)) if (loadedPoints == classifiedPoints): return True return False
def autoEncode(sizes, input, autoencoder_eta=0.000001): ''' Pretraining using stacked autoencoders ''' ae_wb_list = [] for i in range(len(sizes) - 1): inpLayer = sizes[i] hidLayer = sizes[i + 1] print "Running stack", i + 1, "of autoencoding" costs = [] cost = 0 ae = autoencoder.AutoEncoder(inpLayer, hidLayer) #Create autoencoder object if i == 0: for ep in range(400): #400 Epochs cost = ae.train(input, eta=autoencoder_eta) #Train the autoencoder print "Epoch", ep, "Cost :", cost costs.append(cost) #Pass the output of the hidden layer of current stack as input to the next stack input = ae.getHiddenLayerOutput(input) else: for ep in range(400): cost = ae.train(input, eta=autoencoder_eta) print "Epoch", ep, "Cost :", cost costs.append(cost) if (i != len(sizes) - 2): input = ae.getHiddenLayerOutput(input) #Get weights and bias learnt by the autoencoder for wb in ae.getWeightsAndBias(): ae_wb_list.append(wb) return ae_wb_list
def AutoEncoderOutput_UnitTest(): print("AutoEncoder Output UnitTest") inputSize = 144 encoder = autoencoder.AutoEncoder([inputSize, 100, inputSize]) input = np.random.rand(inputSize, 1) output = encoder.FeedForward(input) if (output.shape[0] == inputSize): return True return False
def SaveLoadAutoEncoderParameters_UnitTest(): print("AutoEncoder: Save and Load Parameters Unit Test") encoder = autoencoder.AutoEncoder([435, 100, 435]) initialParameters = encoder.GetParameters() encoder.SaveParameters("C:/Images/testParameters.txt") encoder.LoadParameters("C:/Images/testParameters.txt") finalParameters = encoder.GetParameters() for a, b in zip(initialParameters, finalParameters): for m, n in zip(a, b): for p, q in zip(m, n): if (p == q): return False return True
def trained_autoencoder(dataset, dropout_prob=0.1, path_to_pretrained=None): ''' Returns a model with pretrained parameters Arguments: - dataset: either 'mnist' or 'cifar' - dropout_prob: dropout probability - path_to_pretrained: path to file where parameters are stored ''' if path_to_pretrained is None: path_to_pretrained = '{}_autoencoder_model'.format(dataset) path_to_pretrained = 'models/{}'.format(path_to_pretrained) model = autoencoder.AutoEncoder(dataset, dropout_prob) model.load_state_dict(torch.load(path_to_pretrained)['state_dict']) return model
def train_AE(X_train, X_test, encoder_size, decoder_size, epochs, lr): model = autoencoder.AutoEncoder(encoder_size, decoder_size).to(device) autoencoder.train(model, dataset=X_train, num_epochs=epochs, batch_size=batch_size, lr=lr) # Calculate training error AE_reconstruction = model(X_train) training_error = np.mean( ((X_train - AE_reconstruction[0])**2).cpu().detach().numpy()) # Calculate test error AE_reconstruction = model(X_test) test_error = np.mean( ((X_test - AE_reconstruction[0])**2).cpu().detach().numpy()) return model, training_error, test_error
def autoEncode(sizes, input): """ Pretraining using stacked autoencoders """ assert (input.shape[1] == sizes[0]) ae_eta = 0.0000001 n_epochs = 300 batch_size = 1000 # Batch size # Minibatches for autoencoder training n_batches = input.shape[0] / batch_size ae_wb_list = [] # Weights and bias obtained from autoencoder # Input for the next stack of the autoencoder (Output of previous hidden # layer) nextStackInput = [] for i in range(len(sizes) - 1): inpLayer = sizes[i] hidLayer = sizes[i + 1] ae = autoencoder.AutoEncoder(inpLayer, hidLayer) print("Running stack", i + 1, "of autoencoding") if i == 0: for ep in range(n_epochs): cost_avg = [] for idx in range(n_batches): x = input[idx * batch_size:(idx + 1) * batch_size] cost_avg.append(ae.train(x, eta=ae_eta)) print("Epoch", ep, "Cost :", (sum(cost_avg) / len(cost_avg))) ''' Get output from the hidden layer to pass as input for the next stack ''' nextStackInput = ae.getHiddenLayerOutput(input) else: input = nextStackInput for ep in range(n_epochs): cost_avg = [] for idx in range(n_batches): x = input[idx * batch_size:(idx + 1) * batch_size] cost_avg.append(ae.train(x, eta=ae_eta)) print("Epoch", ep, "Cost :", (sum(cost_avg) / len(cost_avg))) if (i != len(sizes) - 2): nextLayerInput = ae.getHiddenLayerOutput(input) """ Get the weights and bias learnt by the autoencoder """ for wb in ae.getWeightsAndBias(): ae_wb_list.append(wb) return ae_wb_list
def autodec(data, gpu_id): #print (data.shape) scaler = StandardScaler() X_std = scaler.fit_transform(data) initiald = X_std.shape[1] # Feature Dimensions targetd = 500 # TO-DO Change to Desired Output with sys.argv[*] autoEncoder = autoenc.AutoEncoder(initiald, targetd, lr_=1, momentum_=0.001, decay_=0.0001, nesterov_=False) #lr_=0.5 autoEncoder.fit(X_std, gpuid=gpu_id, batch_size=100, epochs=10, verbose=1, validation_split=0.2)
def __init__(self, n, w): """ This initializes a phrase embedding model which is based on a recursive autoencoder (RAE). This model can be trained with backpropagation and stochastic gradient descent Parameters: n : The dimensionality of the input w : A word vector object that contains pre-trained word embeddings """ self.n = n self.w = w self.a = autoencoder.AutoEncoder(self.n) #self.a.paramMatrix = np.array([[-0.66901207, -0.18282628, -0.05600838, -0.93896959], #[-0.10363659, -0.53908909, 0.24603079, 0.50378757]]) #self.a.reconParamMatrix = np.array([[-0.22829916, 0.92183385], #[-0.4777748, 0.47174915], #[ 0.22207423, -0.22005313], #[-0.53727245, -0.70092649]]) self.totalReconstructionError = 0 self.backPropTrainingData = [] self.finalLayerBackPropData = []
def main(): args = parse_program_arguments() device = utils.best_device() test_data = utils.load_mnist_digits( root=args.data_folder, training=False) test_data_loader = torch.utils.data.DataLoader( test_data, batch_size=args.num_images, shuffle=True) # load the model model = autoencoder.AutoEncoder(latent_size=16) model.load_state_dict(torch.load(args.model)) model.to(device) model.eval() utils.plot( model=model, loader=test_data_loader, device=device, num_images=args.num_images)
batch_size = 128 lr = 0.002 optimizer_cls = optim.Adam # Data loader loader = utils.get_data('cifar', _train=True, _transforms=transforms.ToTensor(), _batch_size=batch_size) test_loader = utils.get_data('cifar', _train=False, _transforms=transforms.ToTensor(), _batch_size=batch_size) # Instantiate model auto = autoencoder.AutoEncoder('cifar', 0.1) loss_fn = nn.BCELoss() optimizer = optimizer_cls(auto.parameters(), lr=lr) num_batches = 150 # Training loop for epoch in range(num_epochs): print('Epoch: {}. Time elapsed: {:.1f} minutes'.format( epoch, (time.time() - start) / 60.0)) batch_num = 0 auto.train() for i, (orig, _) in enumerate(loader):
def main(): print("Image Sharpening with Machine Learning\n") print("Sebastian Pendola, NY 2017\n\n") print("1) Train KMean Clustering") print("2) Train AutoEncoders") print("3) Enhance Image") print("4) Display Centroids") print("5) Test on Image") task = int(raw_input("\nChoose a Task: ")) if task == 1: featureSize = int(raw_input("Feature Size: ")) colorChannels = int(raw_input("Color Channels: ")) numberOfCentroids = int(raw_input("Clusters: ")) epochs = int(raw_input("Epochs: ")) useLastCentroids = raw_input("Use last centroids? (y/n) ") startTime = dt.datetime.now().replace(microsecond=0) #images = ("images/Satellite_1.png", "images/Satellite_2.png", "images/Satellite_3.png", "images/Satellite_4.png", "images/Satellite_5.png") images = ("images/image_1.png", "images/image_2.png", "images/image_3.png", "images/image_4.png", "images/image_5.png", "images/image_6.png", "images/image_7.png", "images/image_8.png") data = datamanipulation.SliceImage( datamanipulation.LoadImageData(images), featureSize * colorChannels, featureSize) publisher.PublishMsg("KMean Clustering Started") publisher.PublishMsg( str(numberOfCentroids) + " clusters of size " + str(featureSize) + "x" + str(featureSize)) publisher.PublishCmd("validationgraph") publisher.PublishCmd("flushgraph") KMean = kmean.KMean(featureSize * featureSize * colorChannels, numberOfCentroids) if (useLastCentroids == "y" or useLastCentroids == "Y"): data, centroids = KMean.KMeanClustering( data, datamanipulation.LoadCentroids("images/TempCentroids_" + str(colorChannels) + ".txt"), limit=epochs) else: data, centroids = KMean.KMeanClustering(data, limit=epochs) for centroid in range(0, len(centroids)): points = [x for x in data if x[-3] == centroid] print("Cluster " + str(centroid) + " has " + str(len(points)) + " points") print("Execution Time: " + str(dt.datetime.now().replace(microsecond=0) - startTime)) datamanipulation.SaveCentroids( centroids, "images/TempCentroids_" + str(colorChannels) + ".txt") elif task == 2: learningRate = float(raw_input("Learning Rate: ")) lmbda = float(raw_input("Lambda: ")) epochs = int(raw_input("Epochs: ")) featureSize = int(raw_input("Feature Size: ")) colorChannels = int(raw_input("Color Channels: ")) # Load Centroids and Initialize KMean module centroids = datamanipulation.LoadCentroids("images/TempCentroids_" + str(colorChannels) + ".txt") KMean = kmean.KMean(featureSize * featureSize * colorChannels, len(centroids)) # Load points and classify them #images = ("images/Satellite_1.png", "images/Satellite_2.png", "images/Satellite_3.png", "images/Satellite_4.png", "images/Satellite_5.png") images = ("images/image_1.png", "images/image_2.png", "images/image_3.png", "images/image_4.png", "images/image_5.png", "images/image_6.png", "images/image_7.png", "images/image_8.png") data = datamanipulation.SliceImage( datamanipulation.LoadImageData(images), featureSize * colorChannels, featureSize) data = KMean.KmeanClassification(data, centroids) trainingCosts = [] for centroid in range(0, len(centroids)): encoder = autoencoder.AutoEncoder([ featureSize * featureSize * colorChannels, 100, featureSize * featureSize * colorChannels ]) encoder.LoadParameters("images/EncoderParameters_" + str(colorChannels) + "_" + str(centroid) + ".txt") trainingSet = datamanipulation.CreateTrainingSetFromData( data, centroids, centroid, threshold=False) if (len(trainingSet) > 0): print("Training Samples of size " + str(len(trainingSet[0]))) savePath = "images/EncoderParameters_" + str( colorChannels) + "_" + str(centroid) + ".txt" trainingCosts.append( encoder.Train( trainingSet, learningRate, lmbda, epochs, len(trainingSet) if len(trainingSet) < 20 else 20, path=savePath)) else: print("Training Set " + str(index) + " is empty") trainingCosts.append(-1) for index in range(0, len(centroids)): print("AutoEncoder for Feature " + str(index) + " has a learning cost of " + str(trainingCosts[index])) elif task == 3: featureSize = int(raw_input("Feature Size: ")) colorChannels = int(raw_input("Color Channels: ")) # Load Centroids and Initialize KMean module centroids = datamanipulation.LoadCentroids("images/TempCentroids_" + str(colorChannels) + ".txt") KMean = kmean.KMean(featureSize * featureSize * colorChannels, len(centroids)) # Load reference and target images image_a = datamanipulation.LoadImageData(["images/Satellite_1.png"], colorChannels) image_b = datamanipulation.LoadImageData(["images/Satellite_1_LQ.png"], colorChannels) compare_1 = datamanipulation.CompareImages(image_a, image_b) # Slice reference image and classify slices data = datamanipulation.SliceImage(image_b, featureSize * colorChannels, featureSize) data = KMean.KmeanClassification(data, centroids) for centroid in range(0, len(centroids)): points = [x for x in data if x[-3] == centroid] if (len(points) > 0): encoder = autoencoder.AutoEncoder([ featureSize * featureSize * colorChannels, 100, featureSize * featureSize * colorChannels ]) if (encoder.LoadParameters("images/EncoderParameters_" + str(colorChannels) + "_" + str(centroid) + ".txt")): for point in points: input = np.array(point[:-3]).reshape(144, 1) output = encoder.FeedForward(input / 256.0) * 256.0 image_b = datamanipulation.InsertSubImage( image_b, output.flatten(), featureSize, colorChannels, point[-2], point[-1], reference=image_a) else: print("unable to load encoder") compare_2 = datamanipulation.CompareImages(image_a, image_b) print("Initial Comparation: " + str(compare_1)) print("Final Comparation: " + str(compare_2)) elif task == 4: centroids = datamanipulation.LoadCentroids("images/TempCentroids.txt") datamanipulation.DisplayCentroids(centroids) elif task == 5: featureSize = int(raw_input("Feature Size: ")) colorChannels = int(raw_input("Color Channels: ")) centroids = datamanipulation.LoadCentroids("images/TempCentroids_" + str(colorChannels) + ".txt") datamanipulation.MarkImage("images/Satellite_2.png", centroids, featureSize, colorChannels)
def train(): with tf.Graph().as_default(): with tf.device('/gpu:' + str(0)): ae = autoencoder.AutoEncoder(paras=para_config) print_trainable_vars() reconstr_loss, reconstr, _ = ae.model() optimizer = ae.make_optimizer(reconstr_loss) # metrics for tensorboard visualization with tf.name_scope('metrics'): reconstr_loss_mean, reconstr_loss_mean_update = tf.metrics.mean( reconstr_loss) reset_metrics = tf.variables_initializer([ var for var in tf.local_variables() if var.name.split('/')[0] == 'metrics' ]) tf.summary.scalar('loss/train', reconstr_loss_mean, collections=['train']) tf.summary.scalar('loss/test', reconstr_loss_mean, collections=['test']) summary_op = tf.summary.merge_all('train') summary_test_op = tf.summary.merge_all('test') train_writer = tf.summary.FileWriter( os.path.join(LOG_DIR, 'summary', 'train')) test_writer = tf.summary.FileWriter( os.path.join(LOG_DIR, 'summary', 'test')) saver = tf.train.Saver(max_to_keep=None) # print log_string('Net layers:') log_string(str(ae)) # Create a session config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True config.log_device_placement = False sess = tf.Session(config=config) # Init variables init = tf.global_variables_initializer() sess.run(init) sess.run(reset_metrics) total_batch_idx = 0 for ep_idx in range(para_config['epoch']): log_string('-----------Epoch %d:-------------' % ep_idx) # train one epoch while TRAIN_DATASET.has_next_batch(): sess.run(reset_metrics) if para_config['ae_type'] == 'c2c': input_batch = TRAIN_DATASET.next_batch() elif para_config['ae_type'] == 'n2n': input_batch = TRAIN_DATASET.next_batch_noise_added( noise_mu=para_config['noise_mu'], noise_sigma=para_config['noise_sigma']) elif para_config['ae_type'] == 'np2np': input_batch = TRAIN_DATASET.next_batch_noise_partial_by_percentage( noise_mu=para_config['noise_mu'], noise_sigma=para_config['noise_sigma'], p_min=para_config['p_min'], p_max=para_config['p_max'], partial_portion=para_config['partial_portion']) else: log_string('Unknown ae type: %s' % (para_config['ae_type'])) exit if para_config['data_aug'] is not None: input_batch = TRAIN_DATASET.aug_data_batch( input_batch, scale_low=para_config['data_aug']['scale_low'], scale_high=para_config['data_aug']['scale_high'], rot=para_config['data_aug']['rot'], snap2ground=para_config['data_aug']['snap2ground'], trans=para_config['data_aug']['trans']) _, _ = sess.run([optimizer, reconstr_loss_mean_update], feed_dict={ ae.input_pl: input_batch, ae.is_training: True }) if TRAIN_DATASET.batch_idx % para_config[ 'output_interval'] == 0: reconstr_loss_mean_val, summary = sess.run( [reconstr_loss_mean, summary_op]) sess.run(reset_metrics) log_string( '-----------batch %d statistics snapshot:-------------' % TRAIN_DATASET.batch_idx) log_string(' Reconstruction loss : {:.6f}'.format( reconstr_loss_mean_val)) train_writer.add_summary(summary, total_batch_idx) train_writer.flush() total_batch_idx += 1 # after each epoch, reset TRAIN_DATASET.reset() # test and save if ep_idx % para_config['save_interval'] == 0: # test on whole test dataset sess.run(reset_metrics) TEST_DATASET.reset() while TEST_DATASET.has_next_batch(): if para_config['ae_type'] == 'c2c': input_batch_test = TEST_DATASET.next_batch() elif para_config['ae_type'] == 'n2n': input_batch_test = TEST_DATASET.next_batch_noise_added( noise_mu=para_config['noise_mu'], noise_sigma=para_config['noise_sigma']) elif para_config['ae_type'] == 'np2np': input_batch_test = TEST_DATASET.next_batch_noise_partial_by_percentage( noise_mu=para_config['noise_mu'], noise_sigma=para_config['noise_sigma'], p_min=para_config['p_min'], p_max=para_config['p_max'], partial_portion=para_config['partial_portion']) else: log_string('Unknown ae type: %s' % (para_config['ae_type'])) exit if para_config['data_aug'] is not None: input_batch_test = TEST_DATASET.aug_data_batch( input_batch_test, scale_low=para_config['data_aug']['scale_low'], scale_high=para_config['data_aug']['scale_high'], rot=para_config['data_aug']['rot'], snap2ground=para_config['data_aug']['snap2ground'], trans=para_config['data_aug']['trans']) reconstr_val_test, _ = sess.run( [reconstr, reconstr_loss_mean_update], feed_dict={ ae.input_pl: input_batch_test, ae.is_training: False }) log_string('--------- on test split: --------') reconstr_loss_mean_val, summary_test = sess.run( [reconstr_loss_mean, summary_test_op]) log_string('Mean Reconstruction loss: {:.6f}'.format( reconstr_loss_mean_val)) sess.run(reset_metrics) # reset metrics # tensorboard test_writer.add_summary(summary_test, ep_idx) test_writer.flush() # write out only one batch for check if False: pc_util.write_ply_batch( np.asarray(reconstr_val_test), os.path.join(LOG_DIR, 'pcloud', 'reconstr_%d' % (ep_idx))) pc_util.write_ply_batch( np.asarray(input_batch_test), os.path.join(LOG_DIR, 'pcloud', 'input_%d' % (ep_idx))) # save model save_path = saver.save( sess, os.path.join(LOG_DIR, 'ckpts', 'model_%d.ckpt' % (ep_idx))) log_string("Model saved in file: %s" % save_path)
verbosity_level = False network_structure_list = [ dh.MNIST_WIDTH * dh.MNIST_HEIGHT, # Input layer size 32, dh.MNIST_WIDTH * dh.MNIST_HEIGHT # Output layer size ] # Read input data file_name = sys.argv[1] data = dh.read_data(file_name) random.shuffle(data) N = len(data) nvd = int(0.1 * N) print("Number of images: " + str(N)) print("Number of validation images: " + str(nvd)) print("Number of training data: " + str(N - nvd)) training_data = data[nvd:] validation_data = data[0:nvd] # Setup the network ae_one = ae.AutoEncoder(dh.MNIST_WIDTH, dh.MNIST_HEIGHT, network_structure_list, standard_deviation, initial_bias, loss, verbosity_level) # Train the network. ae_one.train(training_data, validation_data, n_epochs, mini_batch_size, learning_rate)
nc /= nc.max() return nc def novelty_seg(ftr, kernel_size): ftr -= ftr.min() ftr /= ftr.max() n = get_novelty_curve(ftr, kernel_size) print("Finding slices") tp, prop = signal.find_peaks(n, height=np.mean(n) + np.std(n), distance=1) return tp.astype(np.int32) stft_file = sys.argv[1] outPath = sys.argv[2] kernel_size = int(sys.argv[3]) iterations = sys.argv[4] net = ae.AutoEncoder(513, 13) print("performing STFT") x = Wave.read(stft_file).to_mono() X = STFT().process(x).magnitude().T print("done") ae.train_ae(net, X) print("Getting feature vectors") features = ae.get_learnt_features(net, X) print("Computing novelty") boundaries = novelty_seg(features, kernel_size) np.savetxt( os.path.expanduser(outPath + '/' + Path(stft_file).name + '.ae_segs.ds'), boundaries)
# Hyperparameters num_epochs = 15 batch_size = 128 lr = 0.002 optimizer_cls = optim.Adam # Data loader loader = utils.get_data('mnist', _train=True, _transforms=transforms.ToTensor(), _batch_size=batch_size) test_loader = utils.get_data('mnist', _train=False, _transforms=transforms.ToTensor(), _batch_size=batch_size) # Instantiate model auto = autoencoder.AutoEncoder('mnist',0.1) loss_fn = nn.BCELoss() optimizer = optimizer_cls(auto.parameters(), lr=lr) num_batches = 150 # Training loop for epoch in range(num_epochs): print('Epoch: {}. Time elapsed: {:.1f} minutes'.format(epoch, (time.time() - start)/60.0) ) batch_num = 0 auto.train() for i, (orig, _) in enumerate(loader): if batch_num > num_batches:
def __init__(self, inputs, masks, numpy_rng, theano_rng=None, n_ins=4096, hidden_layers_sizes=[200, 100, 100, 200], n_outs=4096): self.sigmoid_layers = [] self.HL_output = [] self.AutoEncoder_layers = [] self.params = [] self.n_layers = len(hidden_layers_sizes) if not theano_rng: theano_rng = RandomStreams(numpy_rng.randint(2**30)) if masks is None: self.Y = T.dmatrix(name='masks') else: self.Y = masks if input is None: self.X = T.dmatrix(name='input') else: self.X = inputs for i in xrange(self.n_layers): # construct the sigmoidal layer # the size of the input if i == 0: input_size = n_ins else: input_size = hidden_layers_sizes[i - 1] # the input to this layer if i == 0: layer_input = self.X else: layer_input = self.sigmoid_layers[-1].output sigmoid_layer = HL.HiddenLayer( rng=numpy_rng, input=layer_input, n_in=input_size, n_out=hidden_layers_sizes[i], activation=theano.tensor.nnet.sigmoid) # add the layer to our list of layers self.sigmoid_layers.append(sigmoid_layer) self.params.extend(sigmoid_layer.params) # Construct an autoencoder that shared weights with this layer and append to list AutoEncoder_layer = AC.AutoEncoder(numpy_rng=numpy_rng, theano_rng=theano_rng, input=layer_input, n_visible=input_size, n_hidden=hidden_layers_sizes[i], Whid=sigmoid_layer.W, bhid=sigmoid_layer.b) self.AutoEncoder_layers.append(AutoEncoder_layer) # We now need to add a logistic layer on top of the MLP self.logLayer = LR.LogisticRegression( input=self.sigmoid_layers[-1].output, masks=self.Y, n_in=hidden_layers_sizes[-1], n_out=n_outs) self.params.extend(self.logLayer.params)
width = 1280 height = 720 DATA_PATH = "./../DATA/" MODEL_DIR = "model/" BEST_MODELE = "best_model.pt" run_dir = "run-1584468877/" LOG_DIR = "./../log/" IMAGE_FOLDER_PATH = DATA_PATH + "Images/train/images/" IMG_SIZE = 512 EXTENTION_JPG = ".jpg" def generate(num_run) run_dir = "run-"+str(num_run)+"/" model = nw.AutoEncoder(num_block=3, depth = 6) data_frame = pd.read_csv(DATA_PATH + "train_label.csv") print(data_frame.shape) model.load_state_dict(torch.load(LOG_DIR +run_dir + MODEL_DIR + BEST_MODELE)) data_submission = pd.DataFrame(columns=['img', 'rle_mask']) for idx in range(data_frame.shape[0]): img_name = os.path.join( IMAGE_FOLDER_PATH, data_frame["img"].iloc[idx] + EXTENTION_JPG) image = cv2.imread(img_name, cv2.IMREAD_COLOR) image = cv2.resize(image, (IMG_SIZE, IMG_SIZE)) assert (image is not None), "This image is None: image name: {}".format(img_name) image = image.transpose((2, 0, 1)) input = torch.from_numpy(image).float() input = input/255 input = input.view(1,image.shape[0],image.shape[1],image.shape[2]) output = (model(input)).view(image.shape[1],image.shape[2])