def get_ndarray(self): (x_train, y_train), (x_test, y_test) = load_cifar10(True) # y is integer at this moment #y_train = np.identity(10)[y_train] #y_test = np.identity(10)[y_test ] print(x_train[:2]) print(x_train.shape) print(y_train.shape) print(x_test.shape) print(y_test.shape) return (x_train, y_train), (x_test, y_test)
def main(): cifar10_data = cifar10.load_cifar10() learning_rate = 0.001 training_epochs = 100 batch_size = 100 n_input = 3072 n_train = cifar10_data.train.num_examples boundary = 6.0 / (32 + 64) weights = { 'encode_conv_weight_1':tf.Variable(tf.random_uniform((3, 3, 3, 32), minval = -boundary, maxval = boundary)), 'encode_conv_weight_2':tf.Variable(tf.random_uniform((3, 3, 32, 64), minval = -boundary, maxval = boundary)), 'encode_conv_weight_3':tf.Variable(tf.random_uniform((3, 3, 64, 64), minval = -boundary, maxval = boundary)), 'encode_dense_weight_1':tf.Variable(xavier_init(1024, 500)), 'decode_dense_weight_1':tf.Variable(xavier_init(500, 1024)), 'decode_conv_weight_3': tf.Variable(tf.random_uniform((3, 3, 64, 64), minval = -boundary, maxval = boundary)), 'decode_conv_weight_2': tf.Variable(tf.random_uniform((3, 3, 64, 32), minval = -boundary, maxval = boundary)), 'decode_conv_weight_1': tf.Variable(tf.random_uniform((3, 3, 32, 3), minval = -boundary, maxval = boundary)) } bias = { 'encode_conv_bias_1':tf.Variable(tf.zeros([32])), 'encode_conv_bias_2':tf.Variable(tf.zeros([64])), 'encode_conv_bias_3':tf.Variable(tf.zeros([64])), 'encode_dense_bias_1':tf.Variable(tf.zeros([500])), 'decode_dense_bias_1':tf.Variable(tf.zeros([1024])), 'decode_conv_bias_3': tf.Variable(tf.zeros([64])), 'decode_conv_bias_2': tf.Variable(tf.zeros([32])), 'decode_conv_bias_1': tf.Variable(tf.zeros([3])) } weights_key = ['encode_conv_weight_1', 'encode_conv_weight_2', 'encode_conv_weight_3', 'encode_dense_weight_1', 'decode_dense_weight_1', 'decode_conv_weight_3', 'decode_conv_weight_2', 'decode_conv_weight_1'] bias_key = ['encode_conv_bias_1', 'encode_conv_bias_2', 'encode_conv_bias_3', 'encode_dense_bias_1', 'decode_dense_bias_1', 'decode_conv_bias_3', 'decode_conv_bias_2', 'decode_conv_bias_1'] x = tf.placeholder(tf.float32, [batch_size, n_input]) reconstruction = convAutoencoder(x, weights, bias, weights_key, bias_key) #loss = tf.sqrt(tf.reduce_mean(tf.square(reconstruction - x))) loss = loss_x_entropy(reconstruction, x) #train_step = tf.train.MomentumOptimizer(learning_rate = learning_rate, momentum = 0.9).minimize(loss) train_step = tf.train.AdamOptimizer(learning_rate = learning_rate, beta1 = 0.9, beta2 = 0.999).minimize(loss) init = tf.initialize_all_variables() sess = tf.Session() summary_dir = pjoin(FLAGS.summary_dir, 'conv_auto_encoder_training_cifar10') summary_writer = tf.train.SummaryWriter(summary_dir, graph_def=sess.graph_def, flush_secs=FLAGS.flush_secs) print("\n\n") print("| Training Step | Cross Entropy | Epoch |") print("|---------------|---------------|----------|") sess.run(init) step = 1 while step * batch_size < training_epochs * n_train: batch_x, batch_y = cifar10_data.train.next_batch(batch_size) #print(np.mean(batch_x)) feed_dict = {x:batch_x} sess.run(train_step, feed_dict = feed_dict) if step % 450 == 0: loss_summary = sess.run(loss, feed_dict = feed_dict) #loss_summary_op = tf.scalar_summary("reconstruction_error", loss_summary) #summary_scalar_str = sess.run(loss_summary_op, feed_dict = {x: batch_x}) #summary_writer.add_summary(summary_scalar_str, step) output = "| {0:>13} | {1:13.4f} | Epoch {2} |"\ .format(step, loss_summary, step * batch_size // n_train + 1) print(output) if step % 900 == 0: image_summary_op = \ tf.image_summary("training_images", tf.reshape(x, (FLAGS.batch_size, 32, 32, 3)), max_images=FLAGS.batch_size) reconstruction_summary_op = \ tf.image_summary("reconstruction_image", tf.reshape(reconstruction, (FLAGS.batch_size, 32, 32, 3)), max_images=FLAGS.batch_size) summary_img_str = sess.run(image_summary_op, feed_dict=feed_dict) summary_writer.add_summary(summary_img_str, step) summary_recon_image_str = sess.run(reconstruction_summary_op, feed_dict = feed_dict) summary_writer.add_summary(summary_recon_image_str, step) step+=1 batch_x, batch_y = cifar10_data.test.next_batch(FLAGS.batch_size) feed_dict = {x: np.array(batch_x)} recon_target = sess.run(reconstruction, feed_dict=feed_dict) np.save("convolutional_autoencoder_cifar10.npy", recon_target.reshape(100, 32, 32, 3)) print("Optimization Finished!")
def _generate_cifar10_dataset(): (Xtr, Ytr), (Xts, Yts) = load_cifar10() print(Xtr.shape, Xts.shape) dataset = CIFAR10Dataset(Xtr, Ytr, Xts, Yts) dataset.save()
import sys import numpy as np import pickle from skimage import color from skimage.transform import resize #Classification from sklearn.metrics import accuracy_score, confusion_matrix from sklearn.ensemble import RandomForestClassifier #Add filter library path sys.path.append('python') #Download and open the database from cifar10 import load_cifar10 Train = load_cifar10(meta='cifar-10-batches-py', mode=5) Test = load_cifar10(meta='cifar-10-batches-py', mode='test') TrainImages = Train["data"] TrainLabels = Train["labels"] TestImages = Test["data"] TestLabels = Test["labels"] #Transform the images to grayscale Train = [] for i in range(0, len(TrainImages)): img = color.rgb2gray(resize(np.asanyarray(TrainImages[i]), (32, 32))) Train.append(img) Test = [] for i in range(0, len(TestImages)):
def main_unsupervised(): with tf.Graph().as_default() as g: sess = tf.Session() num_hidden = FLAGS.num_hidden_layers # The shape of the hidden layers ae_hidden_shapes = [getattr(FLAGS, "hidden{0}_units".format(j + 1)) for j in xrange(num_hidden)] # The shape of the all the layers, including the input layer and the classification layer... Why do we need the classification layer again? ae_shape = [FLAGS.image_pixels] + ae_hidden_shapes + [FLAGS.image_pixels] ae = AutoEncoder(ae_shape, sess) cifar10_data = cifar10.load_cifar10() num_train = cifar10_data.train.num_examples n = 4 with tf.variable_scope("net_training"): input_ = tf.placeholder(dtype=tf.float32, shape=(FLAGS.batch_size, ae_shape[0]), name='ae_input_pl') target_for_loss = ae.net(input_, n) loss = loss_x_entropy(target_for_loss, input_) #loss = tf.sqrt(tf.reduce_mean(tf.square(input_ - target_for_loss))) summary_dir = pjoin(FLAGS.summary_dir, 'auto_encoder_training') summary_writer = tf.train.SummaryWriter(summary_dir, graph_def=sess.graph_def, flush_secs=FLAGS.flush_secs) summary_vars = [ae[key] for key in ae._variables.keys()] hist_summarries = [tf.histogram_summary(v.op.name, v) for v in summary_vars] summary_op = tf.merge_summary(hist_summarries) loss_summary_op_train = tf.scalar_summary("reconstruction error", loss) #train_step = tf.train.MomentumOptimizer(learning_rate = 0.01, momentum = 0.9).minimize(loss) train_step = tf.train.AdamOptimizer(learning_rate = 0.001, beta1 = 0.9, beta2 = 0.999).minimize(loss) sess.run(tf.initialize_all_variables()) print("\n\n") print("| Training Step | Cross Entropy Train | Cross Entropy Test | Layer | Epoch |") print("|---------------|------------------------|-----------------------|--------|----------|") #for step in xrange(FLAGS.pretraining_epochs * num_train): for step in xrange(45000): input_data, input_label = cifar10_data.train.next_batch(FLAGS.batch_size) feed_dict = {input_: np.array(input_data)} loss_summary, loss_value = sess.run([train_step, loss], feed_dict=feed_dict) if step % 450 == 0: summary_str = sess.run(summary_op, feed_dict=feed_dict) summary_writer.add_summary(summary_str, step) total_test_loss = 0 for test_step in xrange(cifar10_data.train.num_examples // FLAGS.batch_size): input_data, input_label = cifar10_data.train.next_batch(FLAGS.batch_size) feed_dict = {input_: np.array(input_data)} test_loss = sess.run(loss, feed_dict = feed_dict) total_test_loss += test_loss * FLAGS.batch_size loss_summary_op_test = tf.scalar_summary("reconstruction_error_test", total_test_loss) loss_summary_op = tf.merge_summary([loss_summary_op_train, loss_summary_op_test]) summary_scalar_str = sess.run(loss_summary_op, feed_dict = feed_dict) summary_writer.add_summary(summary_scalar_str, step) output = "| {0:>13} | {1:19.4f} | {2:19.4f} |Layer {3} | Epoch {4} |"\ .format(step, loss_value, total_test_loss / cifar10_data.train.num_examples, n, step * FLAGS.batch_size//num_train + 1) print(output) if step % 900 == 0: image_summary_op = \ tf.image_summary("training_images", tf.reshape(input_, (FLAGS.batch_size, FLAGS.image_size, FLAGS.image_size, 3)), max_images=FLAGS.batch_size) reconstruction_summary_op = \ tf.image_summary("reconstruction_image", tf.reshape(target_for_loss, (FLAGS.batch_size, FLAGS.image_size, FLAGS.image_size, 3)), max_images=FLAGS.batch_size) summary_img_str = sess.run(image_summary_op, feed_dict=feed_dict) summary_writer.add_summary(summary_img_str, step) summary_recon_image_str = sess.run(reconstruction_summary_op, feed_dict = feed_dict) summary_writer.add_summary(summary_recon_image_str, step) input_data, input_label = cifar10_data.test.next_batch(FLAGS.batch_size) feed_dict = {input_: np.array(input_data)} recon_target = sess.run(target_for_loss, feed_dict=feed_dict) np.save("autoencoder_cifar10.npy", recon_target.reshape(100, 32, 32, 3)) return ae
def main(): cifar10_data = cifar10.load_cifar10() learning_rate = 0.00001 training_epochs = 200 batch_size = 250 n_input = 3072 n_train = cifar10_data.train.num_examples boundary = 6.0 / (32 + 32) weights = { 'encode_conv_weight_1':tf.Variable(tf.random_uniform((5, 5, 3, 32), minval = -boundary, maxval = boundary)), 'encode_conv_weight_2':tf.Variable(tf.random_uniform((5, 5, 32, 64), minval = -boundary, maxval = boundary)), 'encode_conv_weight_3':tf.Variable(tf.random_uniform((5, 5, 64, 128), minval = -boundary, maxval = boundary)), 'encode_fully_connected': tf.Variable(xavier_init(4 * 4 * 128, 1024)), 'encode_output_mean':tf.Variable(xavier_init(1024, 500)), 'encode_output_log_sigma': tf.Variable(xavier_init(1024, 500)), 'decode_dense_weight_1':tf.Variable(xavier_init(500, 1024)), 'decode_dense_weight_2':tf.Variable(xavier_init(1024, 2048)), 'decode_conv_weight_3': tf.Variable(tf.random_uniform((5, 5, 128, 64), minval = -boundary, maxval = boundary)), 'decode_conv_weight_2': tf.Variable(tf.random_uniform((5, 5, 64, 32), minval = -boundary, maxval = boundary)), 'decode_conv_weight_1': tf.Variable(tf.random_uniform((5, 5, 32, 3), minval = -boundary, maxval = boundary)) } bias = { 'encode_conv_bias_1':tf.Variable(tf.zeros([32])), 'encode_conv_bias_2':tf.Variable(tf.zeros([64])), 'encode_conv_bias_3':tf.Variable(tf.zeros([128])), 'encode_fully_connected': tf.Variable(tf.zeros([1024])), 'encode_output_mean':tf.Variable(tf.zeros([500])), 'encode_output_log_sigma': tf.Variable(tf.zeros([500])), 'decode_dense_bias_1':tf.Variable(tf.zeros([1024])), 'decode_dense_bias_2': tf.Variable(tf.zeros([2048])), 'decode_conv_bias_3': tf.Variable(tf.zeros([64])), 'decode_conv_bias_2': tf.Variable(tf.zeros([32])), 'decode_conv_bias_1': tf.Variable(tf.zeros([3])) } weights_key = ['encode_conv_weight_1', 'encode_conv_weight_2', 'encode_conv_weight_3', 'encode_fully_connected', 'encode_output_mean', 'encode_output_log_sigma', 'decode_dense_weight_1', 'decode_dense_weight_2', 'decode_conv_weight_3', 'decode_conv_weight_2', 'decode_conv_weight_1'] bias_key = ['encode_conv_bias_1', 'encode_conv_bias_2', 'encode_conv_bias_3', 'encode_fully_connected', 'encode_output_mean', 'encode_output_log_sigma', 'decode_dense_bias_1', 'decode_dense_bias_2', 'decode_conv_bias_3', 'decode_conv_bias_2', 'decode_conv_bias_1'] x = tf.placeholder(tf.float32, [batch_size, n_input]) reconstruction, cost, recon_loss = createVAE(x, weights, bias, weights_key, bias_key) optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost) init = tf.initialize_all_variables() sess = tf.Session() summary_dir = pjoin(FLAGS.summary_dir, 'conv_vae_cifar10_sbatch') summary_writer = tf.train.SummaryWriter(summary_dir, graph_def = sess.graph_def, flush_secs = FLAGS.flush_secs) sess.run(init) step = 1 print("\n\n") print("| Training Step | Cross Entropy | Epoch |") print("|---------------|---------------|----------|") while step * batch_size < training_epochs * n_train: batch_x, batch_y = cifar10_data.train.next_batch(batch_size) feed_dict = {x:batch_x} sess.run(optimizer, feed_dict = feed_dict) if step % 100 == 0: loss_summary = sess.run(recon_loss, feed_dict = feed_dict) output = "| {0:>13} | {1:13.4f} | Epoch {2} |"\ .format(step, loss_summary, step * batch_size // n_train + 1) print(output) if step % 900 == 0: image_summary_op = \ tf.image_summary("training_images", tf.reshape(x, (250, 32, 32, 3)), max_images=FLAGS.batch_size) reconstruction_summary_op = \ tf.image_summary("reconstruction_image", tf.reshape(reconstruction, (250, 32, 32, 3)), max_images=FLAGS.batch_size) summary_img_str = sess.run(image_summary_op, feed_dict=feed_dict) summary_writer.add_summary(summary_img_str, step) summary_recon_image_str = sess.run(reconstruction_summary_op, feed_dict = feed_dict) summary_writer.add_summary(summary_recon_image_str, step) step+=1 print("Optimization Finished!")
from assignTextons import assignTextons from fbRun import fbRun from fbCreate import fbCreate fb = fbCreate(support=2, startSigma=0.6) # fbCreate(**kwargs, vis=True) for visualization from skimage import color import random file = open("textons.pckl",'rb') textons = pickle.load(file) file.close() file = open("model.pckl",'rb') model = pickle.load(file) file.close() test_cf=load_cifar10(meta='cifar-10-batches-py', mode='test') test_images=test_cf["data"] test_labels=test_cf["labels"] N=random.randrange(0,len(test_labels),1) l=random.sample(range(0,len(test_labels)-1),N) list_test=range(0,N-1) from assignTextons import assignTextons def histc(X, bins): import numpy as np map_to_bins = np.digitize(X,bins) r = np.zeros(bins.shape) for i in map_to_bins: r[i-1] += 1 return np.array(r)
model = open('RF', 'rb') RF = pickle.load(model) model.close() text = open("text", "rb") textons = pickle.load(text) text.close() import sys sys.path.append('python') import numpy as np import cifar10 data = cifar10.load_cifar10(mode="test") images_test, labels_test = cifar10.get_data(data) from fbCreate import fbCreate fb = fbCreate(support=2, startSigma=0.6) k = 16 * 32 from assignTextons import assignTextons from fbRun import fbRun import matplotlib.pyplot as plt import random plt.figure() for i in range(1, 8, 2):
i, format(cm[i, j], fmt), horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.ylabel('True label') plt.xlabel('Predicted label') plt.tight_layout() import sys sys.path.append('python') import numpy as np import cifar10 data = cifar10.load_cifar10(mode=5) images_train, labels_train = cifar10.get_data(data) from fbCreate import fbCreate fb = fbCreate(support=2, startSigma=0.6) k = 16 * 32 from fbRun import fbRun num = 200 sample = np.hstack(images_train[0:num, :, :]) filterResponses = fbRun(fb, sample) from computeTextons import computeTextons map, textons = computeTextons(filterResponses, k)
def main(): cifar10_data = cifar10.load_cifar10() learning_rate = 0.001 training_epochs = 1000 batch_size = 100 n_input = 3072 n_train = cifar10_data.train.num_examples weightsKey = ['encode_h1', 'encode_h2','encode_out_mean', 'encode_out_log_sigma', 'decode_h1', 'decode_h2', 'decode_out_mean', 'decode_out_log_sigma'] biasKey = ['encode_h1', 'encode_h2','encode_out_mean', 'encode_out_log_sigma', 'decode_h1', 'decode_h2', 'decode_out_mean', 'decode_out_log_sigma'] weights = { #Encoder procedure weightsKey[0]: tf.Variable(xavier_init(3072, 1024)), #weightsKey[1]: tf.Variable(xavier_init(1024, 1024)), # Latent space is 16 weightsKey[1]: tf.Variable(xavier_init(1024, 500)), weightsKey[2]: tf.Variable(xavier_init(1024, 500)), #Decode procedure weightsKey[3]: tf.Variable(xavier_init(500, 1024)), #weightsKey[5]: tf.Variable(xavier_init(1024, 1024)), weightsKey[4]: tf.Variable(xavier_init(1024, 3072)), #weightsKey[7]: tf.Variable(xavier_init(500, 784)) } bias = { #Encoder procedure biasKey[0]: tf.Variable(tf.zeros([1024], dtype = tf.float32)), #biasKey[1]: tf.Variable(tf.zeros([1024], dtype = tf.float32)), # Latent space is 16 biasKey[1]: tf.Variable(tf.zeros([500], dtype = tf.float32)), biasKey[2]: tf.Variable(tf.zeros([500], dtype = tf.float32)), #Decode procedure #biasKey[4]: tf.Variable(tf.zeros([1024], dtype = tf.float32)), biasKey[3]: tf.Variable(tf.zeros([1024], dtype = tf.float32)), biasKey[4]: tf.Variable(tf.zeros([3072], dtype = tf.float32)), #biasKey[7]: tf.Variable(xavier_init(500, 784)) } x = tf.placeholder(tf.float32, [batch_size, n_input]) reconstruction, cost, recon_loss, recon_full_loss, latent_loss = createVAE(x, weights, bias, weightsKey, biasKey) optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost) init = tf.initialize_all_variables() sess = tf.Session() summary_dir = pjoin(FLAGS.summary_dir, 'vae_cifar10') summary_writer = tf.train.SummaryWriter(summary_dir, graph_def = sess.graph_def, flush_secs = FLAGS.flush_secs) sess.run(init) step = 1 print("\n\n") print("| Training Step | Cross Entropy | Epoch |") print("|---------------|---------------|----------|") while step * batch_size < training_epochs * n_train: batch_x, batch_y = cifar10_data.train.next_batch(batch_size) feed_dict = {x:batch_x} sess.run(optimizer, feed_dict = feed_dict) reconstruction_, cost_, recon_, recon_full_, latent_full_ = sess.run([reconstruction, cost, recon_loss, recon_full_loss, latent_loss], feed_dict = feed_dict) if (math.isnan(float(cost_))): print(reconstruction_, np.mean(reconstruction_)) print("==================================") print(cost_) print("==================================") print(recon_) print("==================================") print(recon_full_, np.mean(recon_full_)) print("==================================") print(latent_full_, np.mean(latent_full_)) print("==================================") if step % 450 == 0: loss_summary = sess.run(recon_loss, feed_dict = feed_dict) #loss_summary_op = tf.scalar_summary("reconstruction_error", loss_summary) #summary_scalar_str = sess.run(loss_summary_op, feed_dict = {x: batch_x}) #summary_writer.add_summary(summary_scalar_str, step) output = "| {0:>13} | {1:13.4f} | Epoch {2} |"\ .format(step, loss_summary, step * batch_size // n_train + 1) print(output) if step % 1100 == 0: image_summary_op = \ tf.image_summary("training_images", tf.reshape(x, (FLAGS.batch_size, 32, 32, 3)), max_images=FLAGS.batch_size) reconstruction_summary_op = \ tf.image_summary("reconstruction_image", tf.reshape(reconstruction, (FLAGS.batch_size, 32, 32, 3)), max_images=FLAGS.batch_size) summary_img_str = sess.run(image_summary_op, feed_dict=feed_dict) summary_writer.add_summary(summary_img_str, step) summary_recon_image_str = sess.run(reconstruction_summary_op, feed_dict = feed_dict) summary_writer.add_summary(summary_recon_image_str, step) step+=1 batch_x, batch_y = cifar10_data.test.next_batch(FLAGS.batch_size) feed_dict = {x: np.array(batch_x)} recon_target = sess.run(reconstruction, feed_dict=feed_dict) np.save("vae_cifar10.npy", recon_target.reshape(100, 32, 32, 3)) print("Optimization Finished!")
testTextonMapPath = './data/testTextonMap.pkl' if not fileExists(testTextonMapPath): print('Loading test images') testImgs = loadPickle('./data/testFilterResponses.pkl') print('Loading textons') textonPath = './data/mapAndTexton' + str(k) + '.pkl' textons = loadPickle(textonPath)['textons'] print('Asigning textons to test images') textonMap = assignTextons(testImgs, textons.transpose()) toPickle(textonMap, './data/testTextonMap') else: textonMap = loadPickle(testTextonMapPath) print('Loading test labels') testLabels = cf.load_cifar10('./cifar-10-batches-py/', mode='test')['labels'] nTest = len(testLabels) rfPred = [] print('Evaluating on test set') for t in range(nTest): print('\r {:.2f}%'.format((t + 1) * 100 / nTest), end='') img = textonMap[:, t * 32:(t + 1) * 32] histo = histc(img.flatten(), np.arange(k)) rfPred.append(clf.predict([histo])[0]) testCM = confusion_matrix(testLabels, rfPred) toPickle(testCM, './data/testConfusionMatrix') print() print('Test confusion matrix:')
sinit= datetime.now() if not os.path.isdir(os.path.join(os.getcwd(),'cifar-10-batches-py')): url='https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' r=requests.get(url,allow_redirects=True) open('cifar-10-python.tar.gz','wb').write(r.content) tar=tarfile.open("cifar-10-python.tar.gz","r") tar.extractall() tar.close ow() endt=datetime.now()-sinit File.write('Time dowloading database= '+str(endt.total_seconds())+'\n') start = datetime.now() dictTrain = cifar10.load_cifar10(meta='cifar-10-batches-py', mode=1) dictTest = cifar10.load_cifar10(meta='cifar-10-batches-py',mode='test') numTrain=0.1#porcentaje de imagenes que se van a tomar para el train imagesTrain,labelsTrain = cifar10.get_data(dictTrain,sliced=numTrain) imagesTest,labelTest = cifar10.get_data(dictTest,sliced=1) print('Label and Data already loaded') # Obtain concatenated matrices of random pixels n=100; #number of train and test images sz=32 #size of squared images numel=sz*sz #number of selected pixels per image train=np.array([]).reshape(sz,0)
def get_origin_train_test_data(): trainX, trainY, testX, testY = load_cifar10( './cifar10_data/cifar-10-batches-py') return trainX, trainY, testX, testY
toPickle(greys, './data/' + name) print() print(name, "turned and saved to greyscale.") return greys if fileExists('./data/trainImages.pkl') and fileExists( './data/testImages.pkl'): print('Loading greyscale pickled greyscale images...') trainGreys = loadPickle('./data/trainImages.pkl') testGreys = loadPickle('./data/testImages.pkl') print('Loaded greyscale images.') else: print("Loading CIFAR10 data...") trainData = cf.load_cifar10(meta='./cifar-10-batches-py/', mode=1) labels = trainData['labels'] labelIds = np.unique(labels) imgs = [] outLabels = [] np.random.seed(0) for imgId in labelIds: objIDs = np.where(labels == imgId)[0] rand100 = np.random.choice(objIDs, 100, replace=False) outLabels += list(labels[rand100]) imgs += list(trainData['data'][rand100])
def train(): #for minist # trX,_,vlX,_,teX,_ = load_mnist_dataset() # testdata = trX #for cifar10 testdata = load_cifar10('./cifar-10-batches-py') #For 64*64 dataset # ds = DataSet(Use_Real_Data) # testdata = ds.images g = tf.Graph() with g.as_default(): sess = tf.Session() z, image = create_placeholders() d_total_loss, g_total_loss, d_optim, g_optim, precision = loss_function( z, image) saver = tf.train.Saver() sess.run(tf.initialize_all_variables()) module_file = tf.train.latest_checkpoint('./Model') if module_file: saver.restore(sess, module_file) logging.debug("load module file:%s, model restored" % module_file) for epoch in range(Train_Epochs): for step, real_images in enumerate( gen_batches(testdata, batch_size=Batch_size)): batch_images = real_images.reshape( [Batch_size, Image_Size, Image_Size, Image_Channel]) batch_z = np.random.uniform(-1, 1, [Batch_size, 100]).astype( np.float32) #optimize d once, optimize g twice _, dloss, prec = sess.run([d_optim, d_total_loss, precision], feed_dict=create_feed_dict( z, image, batch_z, batch_images)) for _ in range(3): _, gloss = sess.run([g_optim, g_total_loss], feed_dict={z: batch_z}) logging.debug( "Epoch:%s step:%s dloss:%s gloss:%s d_precision:%s" % (epoch, step, dloss, gloss, prec)) if (step) % 1000 == 0: with tf.variable_scope("learn_param", reuse=True): lr = tf.get_variable( "learning_rate", shape=[], dtype=tf.float32, initializer=tf.constant_initializer(Learning_rate), trainable=False) lr = tf.assign(lr, lr * Learning_rate_Decay) logging.debug("learning_rate decay:%6f" % sess.run(lr)) batch_z = np.random.uniform( -1, 1, [Batch_size, 100]).astype(np.float32) # samples = sess.run([sample_image],feed_dict={z:batch_z}) # plot_sample(samples, str(epoch)+"_"+str(step)) logging.debug("Sample saved") saver.save(sess, "./Model/GANModel", global_step=epoch)
# coding: utf-8 import matplotlib.pyplot as plt # from two_layer_net import TwoLayerNet from multi_layer_net import MultiLayerNet from cifar10 import load_cifar10 from optimizer import * (x_train, t_train), (x_test, t_test) = load_cifar10(normalize=True, flatten=True, one_hot_label=True, data_batch_number='1') # network = TwoLayerNet(input_size=3072, hidden_size=200, output_size=10) network = MultiLayerNet(input_size=3072, hidden_size_list=[100, 100, 100], output_size=10, activation='relu', weight_init_std='relu', weight_decay_lambda=0.1, use_dropout=True, dropout_ration=0.5, use_batchnorm=True) iters_num = 10000 train_size = x_train.shape[0] batch_size = 100 learning_rate = 0.1 train_loss_list = [] train_acc_list = [] test_acc_list = []