def get_embedding(sample): dft = np.abs(np.fft.rfft(sample)) dft -= mean dft /= std model = autoencoder.Autoencoder(88201, 100) model.load_parameters(weight1, bias1, weight2, bias2, weight3, bias3) return model(dft).data
def autoencoder_serial(index_name, start, end, lookback=504): # 1 year => 252 trading days c = composition.Composition(index_name) days = utilities.TradingDays(start, end).get_trading_days() basket = {} for d in days: logging.info('getting composition for %s' % d) basket[d] = c.get_composition(d) basket = pd.DataFrame.from_dict(basket, orient='index') r = returns.Returns(basket, start, end) returns_matrix_all = r.get_returns_matrix_all( frequency='daily') # match frequency to that of trading days ARprediction_aic_auto = pd.DataFrame( ) # trading_day, component, lag_length, aic lreg_returns_predictions_AR_auto = pd.DataFrame( ) # predicting returns using the AR predicted components n_day = 0 for trading_day in range(lookback, len(returns_matrix_all)): returns_matrix = returns_matrix_all[n_day:trading_day] n_day += 1 # getting autoencoder components (encoded image), predicting the next trading day using AR. a = autoencoder.Autoencoder(returns_matrix=returns_matrix, n_factors=100) ARprediction_aic1, AR_predicted_components_auto = utilities.predict_components_AR( principal_components=a.encoded_images) ARprediction_aic1['trading_day'] = trading_day + 1 ARprediction_aic_auto = ARprediction_aic_auto.append(ARprediction_aic1) # fitting a linear regression to predict returns from components, and using the AR predicted components (next trading day) to predict the returns. Return_Matrix must be multiplied by 100 (Autoencoder input was multiplied by 100 during training) lreg_returns_prediction_auto = utilities.predict_returns_lreg( principal_components=a.encoded_images, returns_matrix=returns_matrix * 100, predicted_components=AR_predicted_components_auto) lreg_returns_predictions_AR_auto = lreg_returns_predictions_AR_auto.append( pd.DataFrame(lreg_returns_prediction_auto, columns=list(range(1, returns_matrix.shape[1] + 1))), ignore_index=True) print(lreg_returns_predictions_AR_auto.shape) print(lreg_returns_predictions_AR_auto) AR_auto_same_direction = np.where( lreg_returns_predictions_AR_auto.values * returns_matrix_all[lookback:] > 0, 1, 0) AR_auto_same_direction_df = pd.DataFrame( AR_auto_same_direction, columns=list(range(1, returns_matrix_all.shape[1] + 1))) AR_auto_same_direction_percent = sum( np.where( lreg_returns_predictions_AR_auto.values * returns_matrix_all[lookback:] > 0, 1, 0)) / len( returns_matrix_all[lookback:]) AR_auto_same_direction_percent_df = pd.DataFrame( AR_auto_same_direction_percent) return ARprediction_aic_auto, lreg_returns_predictions_AR_auto, AR_auto_same_direction_df, AR_auto_same_direction_percent_df
def mnist(digit=None, torusHack=False, autoencoded=False, which='train', everyNth=1): np.random.seed(1) # TODO Not the right place to do this. datasetFile = "mnist.pkl.gz" f = gzip.open(datasetFile, 'rb') datasets = cPickle.load(f) train_set, valid_set, test_set = datasets f.close() if which == 'train': input, output = train_set elif which == 'validation': input, output = valid_set elif which == 'test': input, output = test_set else: assert which in ('train', 'validation', 'test') input = input.reshape((-1, 28, 28)) if digit is not None: input = input[output == digit] if torusHack: # This is a SINGLE sample, translated and multiplied. sample = input[0] inputRows = [] for dx in range(28): for dy in range(28): s = sample.copy() s = np.hstack((s[:, dy:], s[:, :dy])) s = np.vstack((s[dx:, :], s[:dx, :])) inputRows.append(s) input = np.array(inputRows) input = np.vstack([[input] * 10]) input = np.random.permutation(input) input = input[::everyNth] input = input.astype(np.float32) if autoencoded: autoencoderFile = "../lasagne-demo/conv_ae.pkl" mu = 0.13045 sigma = 0.30729 ae = autoencoder.Autoencoder(cPickle.load(open(autoencoderFile, 'r')), mu=mu, sigma=sigma) ae.split() encodedInput = ae.encode(input.reshape((-1, 1, 28, 28))) assert encodedInput.shape[1] == 40 # encodedInput = encodedInput.reshape((-1, 8, 5)) # print encodedInput.shape # return encodedInput, (8, 5) decodedInput = ae.decode(encodedInput) return decodedInput.reshape((-1, 28, 28)), (28, 28) else: return input, (28, 28)
def autoencoder_one_day(self, trading_day): returns_matrix = self.returns_matrix_all[trading_day - self.lookback:trading_day] # getting autoencoder components (encoded image), predicting the next trading day using AR a = autoencoder.Autoencoder(returns_matrix=returns_matrix, n_factors=100) ARprediction_aic, AR_predicted_components_auto = utilities.predict_components_AR( principal_components=a.encoded_images) ARprediction_aic['trading_day'] = trading_day + 1 # fitting a linear regression to predict returns from components, and using the AR predicted components (next trading day) to predict the returns. # Return_Matrix must be multiplied by 100 (Autoencoder input was multiplied by 100 during training) lreg_returns_prediction_auto_AR = utilities.predict_returns_lreg( principal_components=a.encoded_images, returns_matrix=returns_matrix * 100, predicted_components=AR_predicted_components_auto) lreg_returns_prediction_AR_auto = pd.DataFrame( lreg_returns_prediction_auto_AR, columns=list(range(1, returns_matrix.shape[1] + 1))) lreg_returns_prediction_AR_auto['trading_day'] = trading_day + 1 # predicting returns from AR components using decoder deco_returns_prediction_auto_AR = a.decoder.predict( AR_predicted_components_auto.to_numpy()) deco_returns_prediction_AR_auto = pd.DataFrame( deco_returns_prediction_auto_AR, columns=list(range(1, returns_matrix.shape[1] + 1))) deco_returns_prediction_AR_auto['trading_day'] = trading_day + 1 # predicting the next trading day using ARMA ARMA_predicted_components_auto = utilities.predict_components_ARMA( principal_components=a.encoded_images) # fitting a linear regression to predict returns from components, and using the ARMA predicted components (next trading day) to predict the returns. # Return_Matrix must be multiplied by 100 (Autoencoder input was multiplied by 100 during training) lreg_returns_prediction_auto_ARMA = utilities.predict_returns_lreg( principal_components=a.encoded_images, returns_matrix=returns_matrix * 100, predicted_components=ARMA_predicted_components_auto) lreg_returns_prediction_ARMA_auto = pd.DataFrame( lreg_returns_prediction_auto_ARMA, columns=list(range(1, returns_matrix.shape[1] + 1))) lreg_returns_prediction_ARMA_auto['trading_day'] = trading_day + 1 # predicting returns from ARMA components using decoder deco_returns_prediction_auto_ARMA = a.decoder.predict( ARMA_predicted_components_auto.to_numpy()) deco_returns_prediction_ARMA_auto = pd.DataFrame( deco_returns_prediction_auto_ARMA, columns=list(range(1, returns_matrix.shape[1] + 1))) deco_returns_prediction_ARMA_auto['trading_day'] = trading_day + 1 print(lreg_returns_prediction_ARMA_auto) return ARprediction_aic, lreg_returns_prediction_AR_auto, lreg_returns_prediction_ARMA_auto, deco_returns_prediction_AR_auto, deco_returns_prediction_ARMA_auto
def pretrain_layer(self, layer_idx, max_iter, dataset): """ Pretrains network layer using autoencoder. """ shape = (self.shape[layer_idx], self.shape[layer_idx + 1], self.shape[layer_idx]) lae = ae.Autoencoder(0.01, shape, self.session) for i in range(max_iter): x, y = dataset.train.next_batch(50) if layer_idx > 0: # Get representation of the input on the layer_idx'th layer x = self.feed_forward(layer_idx).eval({self.x: x}, session=self.session) lae.train_batch((x,)) self.weights[layer_idx] = tf.Variable(lae.weights[0]) self.biases[layer_idx] = tf.Variable(lae.biases[0])
def main(): os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' DATASET_DIRECTORY = '../data_part1' X, y, X_hidden = dataset_manip.load_dataset(DATASET_DIRECTORY) X = resize_image_set(X, (64, 64, 1)) X_hidden = resize_image_set(X_hidden, (64, 64, 1)) print('X.shape = ' + str(X.shape)) print('X_hidden.shape = ' + str(X_hidden.shape)) X_train, X_validation, y_train, y_validation = dataset_manip.split_dataset(X, y, rate = 0.9) model = autoencoder.Autoencoder(input_shape = X.shape[1 : ], model_path = './model_files/autoencoder_model', batch_size = 8, first_run = True) print(model.measure_loss(X_validation)) model.train(X_train, X_validation, num_epochs = 100) print(model.measure_loss(X_validation))
def __load_autoencoder(self): """ Loads the autoencoder model. """ net = autoencoder.Autoencoder(self._input_shape, eye_shape=self._eye_shape) self.__autoencoder = net.build() # Load the saved weights. logger.info("Loading autoencoder weights from %s." % (self.__autoenc_file)) self.__autoencoder.load_weights(self.__autoenc_file) # Load the cluster data. logger.info("Loading clusters from %s." % (self.__cluster_file)) cluster_file = file(self.__cluster_file, "rb") self.__clusters = pickle.load(cluster_file) # Freeze the model. utils.freeze_all(self.__autoencoder)
def main(): autoencoder1 = autoencoder.Autoencoder( layer_dims=[784, 128, 36, 128, 784], epochs=1, activity_regularizer=None, #regularizers.l1(0), use_pretrained=False, model_name="128_36") ### TODO: CHANGE THE NAME!!!!!!!!! m = load_model("128_36_autoencoder.h5") # m.compile(optimizer='adadelta', loss='binary_crossentropy') # print(m.layers[0].get_weights()) for layer in m.layers: weights = layer.get_weights() for i in range(len(weights)): print(i) print(weights[i].shape) print(type(weights[0]))
def __init__(self, d_input, d_hidden_autoencoders, d_out, corruptions, batch_size, pre_lr=0.001, ft_lr=0.1): super(SDA, self).__init__() self.d_input = d_input self.d_hidden_autoencoders = list(d_hidden_autoencoders) self.d_out = d_out self.corruptions = corruptions self.batch_size = batch_size self.pre_lr = pre_lr self.ft_lr = ft_lr # Create one sequential module containing all autoencoders and logistic layer self.sequential = torch.nn.Sequential() # Create the Autoencoders self.autoencoders_ref = [] for i, (d, c) in enumerate(zip(d_hidden_autoencoders, corruptions)): if i == 0: curr_input = d_input else: curr_input = d_hidden_autoencoders[i - 1] dna = ae.Autoencoder(curr_input, d, batch_size, corruption=c) self.autoencoders_ref.append("autoencoder_" + str(i)) self.sequential.add_module(self.autoencoders_ref[-1], dna) # Create the Logistic Layer self.sequential.add_module( "top_linear1", torch.nn.Linear(d_hidden_autoencoders[-1], d_out, bias=True)) self.sequential.top_linear1 = torch.nn.Linear( d_hidden_autoencoders[-1], d_out, bias=True) self.sequential.top_linear1.weight.data = torch.zeros( self.sequential.top_linear1.weight.data.size()) self.sequential.top_linear1.bias.data = torch.zeros(d_out) self.sequential.add_module("softmax", torch.nn.LogSoftmax())
def autoencoder_example(): mnist_train = np.fromfile('mnist_training.csv', sep=" ") mnist_train = np.array(mnist_train.reshape(256, 1000)).transpose() mnist_targets = np.fromfile('mnist_training_targets.csv', sep=" ") mnist_targets = np.array(mnist_targets.reshape(10, 1000)).transpose() X = mnist_train y = mnist_targets X, y, X_val, y_val, X_test, y_test = neur.cross_validation_sets( np.array(X), np.array(y), "digits_rbm_mnist_autoencode") X_val = np.vstack([X_val, X_test]) y_val = np.vstack([y_val, y_test]) hid_layer = 300 autoenc = ac.Autoencoder(X.shape[1], hid_layer, denoise=True, denoise_percent=0.5) costs, val_costs = autoenc.optimize(X, iters=3000, learning_rate=0.05, val_set=X_val) h_x, a = autoenc.forward_prop(X_val) print h_x[0:3, 0:10] print X_val[0:3, 0:10] print "training error:", costs[-1:][0] print "validation error:", val_costs[-1:][0] print "lowest validation error:", min(val_costs) plt.plot(costs, label='cost') plt.plot(val_costs, label='val cost') plt.legend() plt.ylabel('error rate') plt.show()
# Training Data cfg = utils.get_cfg(sys.argv[1]) file_list = utils.load_data(cfg['trainpath']) batch = minibatch(file_list, cfg['batchsize'], cfg['width'], cfg['height'], True) # Training Parameters learning_rate = cfg['learningrate'] num_steps = cfg['maxepoch'] batch_size = cfg['batchsize'] # Network Parameters num_hidden_1 = cfg['hidden1num'] # 1st layer num features num_hidden_2 = cfg['hidden2num'] # 2nd layer num features (the latent dim) num_input = cfg['width'] * cfg['height'] * 1 # data input network = ae.Autoencoder(num_input, num_hidden_1, num_hidden_2) # tf Graph input (only pictures) x = tf.placeholder("float", [None, num_input]) encoded, decoded = network.autoencode(x) # Define loss and optimizer, minimize the squared error loss = network.loss(x, decoded) optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss) # Initialize the variables (i.e. assign their default value) init = tf.global_variables_initializer() # Start Training # Start a new TF session with tf.Session() as sess:
import matplotlib.pyplot as plt import tensorflow as tf import numpy as np import autoencoder from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets('MNIST_data', one_hot=True) n_samples = mnist.train.num_examples sess = tf.Session() np.random.seed(0) tf.set_random_seed(0) batch_size = 100 num_epochs = 50 display_step = 2 network_architecture = [784, 500, 500, 2] ae = autoencoder.Autoencoder(sess, network_architecture, batch_size=batch_size) ae.fit(mnist.train.images, num_epochs) x_sample, y_sample = mnist.test.next_batch(5000) z_mu = ae.transform(x_sample) plt.figure(figsize=(8, 6)) plt.scatter(z_mu[:, 0], z_mu[:, 1], c=np.argmax(y_sample, 1)) plt.colorbar() plt.savefig('test_ae.png')
def autoencoder_example(): mnist_train = np.fromfile('mnist_training.csv', sep=" ") mnist_train = np.array(mnist_train.reshape(256, 1000)).transpose() mnist_targets = np.fromfile('mnist_training_targets.csv', sep=" ") mnist_targets = np.array(mnist_targets.reshape(10, 1000)).transpose() X = mnist_train y = mnist_targets X, y, X_val, y_val, X_test, y_test = neur.cross_validation_sets( np.array(X), np.array(y), "digits_rbm_mnist_autoencode") X_val = np.vstack([X_val, X_test]) y_val = np.vstack([y_val, y_test]) hid_layer = 300 autoenc = ac.Autoencoder(X.shape[1], hid_layer, denoise=True, denoise_percent=0.5) costs, val_costs = autoenc.optimize(X, iters=1500, learning_rate=0.1, val_set=X_val) print "::: first encoding done :::" print "training error:", costs[-1:][0] print "validation error:", val_costs[-1:][0] print "lowest validation error:", min(val_costs) plt.plot(costs, label='cost') plt.plot(val_costs, label='val cost') plt.legend() plt.ylabel('error rate') plt.show() thetas = neur.create_initial_thetas([64, hid_layer, 10], 0.12) thetas[0] = autoenc.encode_weights thetas, costs, val_costs = neur.gradient_decent(X, y, learning_rate=0.01, hidden_layer_sz=hid_layer, iter=5000, thetas=thetas, X_val=X_val, y_val=y_val, do_dropout=True, dropout_percentage=0.9, do_early_stopping=True) h_x, a = neur.forward_prop(X_val, thetas) print "percentage correct predictions: ", ut.percent_equal( ut.map_to_max_binary_result(h_x), y_val) print "training error:", costs[-1:][0] print "validation error:", val_costs[-1:][0] print "lowest validation error:", min(val_costs) plt.plot(costs, label='cost') plt.plot(val_costs, label='val cost') plt.legend() plt.ylabel('error rate') plt.show()
import pickle import numpy as np import autoencoder training_data, validation_data, test_data = mnist_loader.load_data_wrapper() # only get x inputs training_data, test_data = np.array(list(training_data))[:, 0], np.array( list(test_data))[:, 0] training_data, test_data = np.array( list(map(lambda x: np.squeeze(x), training_data))), np.array( list(map(lambda x: np.squeeze(x), test_data))) print("processed data") # [ 784, 400, L50, 400, 784] autoencoder = autoencoder.Autoencoder([784, 400], [400, 784], 50) print("finished building autoencoder") autoencoder.train(training_data, test_data) print("finished training!") '''= # Creates filename and prepares network properties(performance and parameters) for saving # name follows naming scheme: inputsize_layer1size_layer2size_...outputsize file_name = str(net.sizes).replace("[","").replace("]","").replace(" ","").replace(",","_")+'.pkl' new_net_properties = [net.performance, net.weights, net.biases, ] Saves network properties (learned parameters and performance). If the shape had been previously trained, it will override previous saved file if new performance is better. If it is a new shape, it will save to a new file
i=0 for filename in wordlists.fileids(): brut_data.append(wordlists.words(filename)) label[i] = random.randint(0,1)#### !!!!!!!!!! i+=1 corpus = utils.TFIDFvectorize(utils.word_to_index(brut_data)) return corpus, label #Main if __name__ == "__main__": corpus, label = load_data() n = corpus.shape[1] batch_size = corpus.shape[0] kw = utils.extract_keywords(corpus,label,2) print kw idx, corpus = utils.next_batch(batch_size, corpus, np.array([1])) pml, pcl = utils.extract_pair(label, 50, idx) autoencoder = au.Autoencoder(n, batch_size, 200, 300, corpus, \ kw, pml, pcl) autoencoder.init_placeholder() autoencoder.init_weights() autoencoder.init_biases() autoencoder.init_layers() autoencoder.init_mask() autoencoder.init_losses() autoencoder.train(1500, 0.01, [float(sys.argv[2]), float(sys.argv[3]), \ float(sys.argv[4])]) autoencoder.plot_loss(sys.argv[5], \ "Variation des losses : a0= %s a1= %s a2= %s "\ % (sys.argv[2],sys.argv[3],sys.argv[4]))
num_epochs = 500 print_freq = 400 save_freq = 8000 learning_rate = 0.005 filename = "mnist.pt" MNIST_data = tv.datasets.MNIST("data/MNIST/", train = True, download = True, transform = T.ToTensor()) train_sampler = D.sampler.SubsetRandomSampler(range(0, int(0.9995 * len(MNIST_data)))) test_sampler = D.sampler.SubsetRandomSampler(range(int(0.9995*len(MNIST_data)), len(MNIST_data)-1)) trainloader = D.DataLoader(MNIST_data, sampler=train_sampler) testloader = D.DataLoader(MNIST_data, sampler=test_sampler) autoenc = autoencoder.Autoencoder(in_out_size, encoded_size) def load_saved(): if isfile("saved_models/" + filename): autoenc.load_state_dict(torch.load("saved_models/" + filename)) print("loading saved model") if (sys.argv[1] == "train"): if "--load" in sys.argv: load_saved() train.train(autoenc, trainloader, filename, print_freq, save_freq, num_epochs, learning_rate) elif (sys.argv[1] == "test"): load_saved() test.test(autoenc, testloader, filename) else: train.train(autoenc, trainloader, filename, print_freq, save_freq, num_epochs, learning_rate)
l5 = layers.FCLayer(shape5, afuns.LinearActivationFunction(), use_bias=True) l6 = layers.FCLayer(shape6, afuns.SigmoidActivationFunction(), use_bias=True) l7 = layers.FCLayer(shape7, afuns.ReluActivationFunction(), use_bias=True) l8 = layers.FCLayer(shape8, afuns.ReluActivationFunction(), use_bias=True) mnist = scipy.io.loadmat('./data/mnist-original.mat') data = mnist['data'].T / 255 labels = mnist['label'].T data = data[:20000, :] labels = labels[:20000, :] train, test, label_train, label_test = train_test_split(data, labels, test_size=0.33) layers = [l1, l2, l3, l4, l5, l6, l7, l8] autoenc = autoencoder.Autoencoder(layers) initial_weights = autoenc.net.get_weights() # SGD momentum autoenc.net.set_weights(initial_weights) hist_sgd_m = autoenc.run_sgd(train.T, num_epoch=50, display=True) # SGD autoenc.net.set_weights(initial_weights) hist_sgd_m = autoenc.run_sgd(train.T, momentum=0, num_epoch=50, display=True) # RMSprop autoenc.net.set_weights(initial_weights) hist_rmsprop = autoenc.run_rmsprop(train.T, num_epoch=50, display=True)
''' Import ''' import numpy as np import scipy.misc import img_dataset as ig import tensorflow as tf import autoencoder as md print('beginning training') minst = ig.ImgDataset("train-images-idx3-ubyte.gz") ds = md.Autoencoder(28 * 28) ds.train() print('training complete')
for j in range(2000): rand = ra.randint(0, int(len(data) * .5) - 5) ann.partial_fit(data[rand:rand + 5]) return ann def train(ann, data): for i in range(int(len(data) * .05), len(data), 1): ann.partial_fit([data[i]]) return ann def test(ann, data): errors = np.zeros((len(data), )) for i in range(len(data)): errors[i] = ann.calc_total_cost([data[i]]) return errors if __name__ == '__main__': data = get_data('monday_reduced.csv') ann = ae.Autoencoder(len(data[0]), len(data[0] * .75)) ann = train_batches(ann, data) print("Done batches") ann = train(ann, data) print("Done training") del data data2 = np.genfromtxt('tuesday_reduced.csv') errors = test(ann, data2) np.savetxt('errors_single.csv', errors)
errors[i] = outer_layer.calc_total_cost([error_layer]) return errors def stupid(): print(len(ensemble_errors)) print(ensemble_errors) if __name__ == '__main__': error_layer = np.zeros((len(mapping),)) train_data = get_data('C:/CICIDS/monday_reduced.csv') shape = np.shape(train_data) for a in mapping: ensemble_layer.append(ae.Autoencoder(len(a), int(len(a)*.75))) outer_layer = ae.Autoencoder(len(ensemble_layer), int(len(ensemble_layer)*.75)) ensemble_layer, outer_layer = train_ensemble_batches(train_data, mapping, ensemble_layer, outer_layer) ensemble_layer, outer_layer = train(train_data, shape, mapping, ensemble_layer, outer_layer) del train_data print("Done Training") data2 = get_data('C:/CICIDS/tuesday_reduced.csv') errors = test(data2, ensemble_layer, outer_layer, mapping) np.savetxt('errors_tuesday_ensemble.csv', errors) ''' #Stuff might need to look at later #train_data = np.delete(train_data, [61, 60, 59, 58, 57, 56, 49, 33, 32, 31], axis = 1)
def __init__(self, in_path_photo=None, in_path_oil=None, autoencoder_path=None, num_epochs=100, batch_size=50, learning_rate=0.0002, recon_loss_weight=10, penalty_coef=10, verbose=True): """ This class implements the siamese architecture. :param in_path_photo: (string) the file path indicating the location of the training data for photographs. :param in_path_oil: the file path indicating the location of the training data for oil. :param autoencoder_path: (string) the path where the save files of the autoencoders are stored. :param num_epochs: (int) the number of epochs. :param batch_size: (int) the batch size. :param learning_rate: (int) the learning rate for the Adam optimizer. :param recon_loss_weight: (float) the parameter that scales the cycle consistency / reconstruction loss (beta) :param penalty_coef: (float) the penalty coefficient for the Wasserstein GAN (lambda) :param verbose: (boolean) if true, the training process is printed to console """ self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.use_cuda = torch.cuda.is_available() self.in_path_photo = in_path_photo self.in_path_oil = in_path_oil self.num_epochs = num_epochs self.batch_size = batch_size self.learning_rate = learning_rate self.recon_loss_weight = recon_loss_weight self.penalty_coef = penalty_coef self.verbose = verbose self.start_epoch = 1 self.d_photo_losses = [] self.d_oil_losses = [] self.g_photo_losses = [] self.g_oil_losses = [] self.photo_rec_losses = [] self.oil_rec_losses = [] self.auto_photo = autoencoder.Autoencoder() self.auto_photo.load(autoencoder_path + 'autoencoder_photo_20.pth') self.auto_photo.eval() self.auto_oil = autoencoder.Autoencoder() self.auto_oil.load(autoencoder_path + 'autoencoder_oil_20.pth') self.auto_oil.eval() self.map_v_to_u = model.Map().cuda() if self.use_cuda else model.Map() self.map_u_to_v = model.Map().cuda() if self.use_cuda else model.Map() self.v_to_u_optimizer = torch.optim.Adam(self.map_v_to_u.parameters(), lr=learning_rate, betas=(0.5, 0.9)) self.u_to_v_optimizer = torch.optim.Adam(self.map_u_to_v.parameters(), lr=learning_rate, betas=(0.5, 0.9)) self.discriminator_photo = model.Discriminator().cuda( ) if self.use_cuda else model.Discriminator() self.discriminator_oil = model.Discriminator().cuda( ) if self.use_cuda else model.Discriminator() self.d_photo_optimizer = torch.optim.Adam( self.discriminator_photo.parameters(), lr=learning_rate, betas=(0.5, 0.9)) self.d_oil_optimizer = torch.optim.Adam( self.discriminator_oil.parameters(), lr=learning_rate, betas=(0.5, 0.9))
import tensorflow as tf batch_size = 32 epochs = 10 learning_rate = 1e-2 momentum = 9e-1 code_dim = 2 original_dim = bops.shape[1] hidden_dim = min(original_dim * 10, 100) weight_lambda = 1e-5 training_dataset = tf.data.Dataset.from_tensor_slices(bops).batch(batch_size) autoencoder = ae.Autoencoder(original_dim=original_dim, code_dim=code_dim, hidden_dim=hidden_dim, weight_lambda=weight_lambda) #opt = tf.optimizers.SGD(learning_rate=learning_rate, momentum=momentum) opt = tf.optimizers.Adam(learning_rate=learning_rate) with open("loss_%s" % input_filename, "w") as loss_file: real_step = 0 for epoch in range(epochs): for step, batch_features in enumerate(training_dataset): ae.train(ae.loss, autoencoder, opt, batch_features) loss_value = ae.loss(autoencoder, batch_features) real_step += 1 print("%d %f" % (real_step, loss_value), file=loss_file) encoded_bops = autoencoder.encoder(tf.constant(bops))
test_image_size = test_image.get_shape().as_list()[1:3] patch_size = 64 stride = 16 ksizes = [1, patch_size, patch_size, 1] strides = [1, stride, stride, 1] rates = [1, 1, 1, 1] train_image_patches = tf.image.extract_patches(train_image, ksizes, strides, rates, 'VALID') train_image_patches = tf.reshape(train_image_patches, [-1, patch_size, patch_size, 3]) test_image_patches = tf.image.extract_patches(test_image, ksizes, strides, rates, 'VALID') test_patches_count = test_image_patches.get_shape().as_list()[1:3] test_image_patches = tf.reshape(test_image_patches, [-1, patch_size, patch_size, 3]) network = autoencoder.Autoencoder(patch_size) try: network.load("model") except IOError: network.train(test_image_patches, "model") reconstructed = network(test_image_patches) debug = True if debug: fig=plt.figure(figsize=(15, 4)) offset = int(368 / stride) * test_patches_count[1] + int(480 / stride) cols = 10 for i in range(1, cols): fig.add_subplot(2, cols, i)
''' Import ''' import numpy as np import scipy.misc import img_dataset as ig import tensorflow as tf import autoencoder as md ds = md.Autoencoder(28*28, sample=True) ds.sample()