def task5(self, args, path='.'): """ Use as: -task 5 --layers # --hashes # --k # --imageId # """ if args.layers == None or args.hashes == None or \ args.k == None or args.imageId == None: raise ValueError( 'Layers, Hashes, Vectors, K, and IMG must all be defined for task 5.' ) layers = int(args.layers) hashes = int(args.hashes) t = int(args.k) imageId = args.imageId if args.vectors: vectors = str(args.vectors) # YOUR CODE HERE lsh = LSH() nearest = lsh.main(layers, hashes, imageId, vectors=(), t=t, database=self.__database__) show_images(nearest, self.__database__) save_images(nearest, self.__database__, join(path, 'out'))
def test(ctx, enc, dec, gdc, test_data): global test_idx ae_metric = mx.metric.MSE() gd_metric = mx.metric.Accuracy() samples = [] for images, labels in test_data: gauss_yes = nd.ones((labels.shape[0], 1), ctx=ctx) features = encode(enc, images, labels) images_out = decode(dec, features, labels) ae_metric.update([images], [images_out]) gauss_fit = gdc(features) gd_metric.update([gauss_yes], [gauss_fit]) idx = np.random.randint(images.shape[0]) samples.append( mx.nd.concat(images[idx], images_out[idx], dim=2)[0].asnumpy()) name, mse = ae_metric.get() print(' AutoEncoder: {}={:.4f}'.format(name, mse)) name, mse = gd_metric.get() print(' GaussDiscriminator: feature space satisfaction {}={:.4f}'.format( name, mse)) try: imgdir = '/tmp/mnist' save_images(samples[::2], imgdir, test_idx * 1000) test_idx += 1 print(" test images written to", imgdir) except Exception as e: print(" writing images failed:", e)
def train(self): # load train datasets (X_train, Y_train), (_, _) = cifar10.load_data() X_train = (X_train.astype(np.float32) - 127.5) / 127.5 X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 3) d_opt = Adam(lr=1e-5, beta_1=0.1) self.discriminator.model.compile(loss='binary_crossentropy', optimizer=d_opt) self.discriminator.model.trainable = False dcgan = Sequential([self.generator.model, self.discriminator.model]) g_opt = Adam(lr=2e-4, beta_1=0.5) self.generator.model.compile(loss='binary_crossentropy', optimizer='Adam') dcgan.compile(loss='binary_crossentropy', optimizer=g_opt) num_batches = int(X_train.shape[0] / self.BATCH_SIZE) for epoc in xrange(self.NUM_EPOCH): for batch_index in xrange(num_batches): noise = np.array([ np.random.uniform(-1, 1, 100) for _ in range(self.BATCH_SIZE) ]) image_batch = X_train[batch_index * self.BATCH_SIZE:(batch_index + 1) * self.BATCH_SIZE] generated_images = self.generator.model.predict(noise, verbose=0) if batch_index % 100 == 0: if not os.path.exists(self.GENERATED_IMAGE_PATH): os.mkdir(self.GENERATED_IMAGE_PATH) util.save_images( generated_images, self.GENERATED_IMAGE_PATH + "{:04d}_{:04d}.png".format(epoc, batch_index)) X = np.concatenate((image_batch, generated_images)) y = [1] * self.BATCH_SIZE + [0] * self.BATCH_SIZE self.discriminator.model.trainable = True d_loss = self.discriminator.model.train_on_batch(X, y) self.discriminator.model.trainable = False noise = np.array([ np.random.uniform(-1, 1, 100) for _ in range(self.BATCH_SIZE) ]) g_loss = dcgan.train_on_batch(noise, [1] * self.BATCH_SIZE) print("epoch: {}, batch: {}, d_loss:{}, g_loss:{}".format( epoc, batch_index, d_loss, g_loss)) self.generator.model.save_weights('generator.h5') self.discriminator.model.save_weights('discriminator.h5')
def sample_save(self, step): test_files = glob(os.path.join(self.data_dir, 'test', '*')) # [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save testA_list = random.sample(test_files, 10) testB_list = random.sample(test_files, 10) attrA_list = [ self.attr_list[os.path.basename(val)] for val in testA_list ] attrB_list = [ self.attr_list[os.path.basename(val)] for val in testB_list ] # get batch images and labels attrA, attrB = preprocess_attr(self.attr_names, attrA_list, attrB_list, self.attr_keys) imgA, imgB = preprocess_image(testA_list, testB_list, self.image_size, phase='test') dataA, dataB = preprocess_input(imgA, imgB, attrA, attrB, self.image_size, self.n_label) # generate fakeB feed = {self.real_A: dataA} fake_B = self.sess.run(self.fake_B, feed_dict=feed) # save samples sample_file = os.path.join(self.sample_dir, '%06d.jpg' % (step)) save_images(imgA, imgB, fake_B, self.image_size, sample_file, num=10)
def task3(self, args, path='.'): """ -task 3 --k # """ if args.k == None: raise ValueError('K must be defined for task 3.') k = int(args.k) # YOUR CODE HERE. G = self.__graph__.get_adjacency() images = self.__graph__.get_images() n = G.shape[0] s = 0.86 maxerr = 0.01 # transform G into markov matrix A A = csc_matrix(G, dtype=np.float) rsums = np.array(A.sum(1))[:, 0] ri, ci = A.nonzero() A.data /= rsums[ri] # bool array of sink states sink = rsums == 0 # Compute pagerank r until we converge ro, r = np.zeros(n), np.ones(n) # account for sink states Di = sink / float(n) # account for teleportation to state i Ei = np.ones(n) / float(n) # while np.sum(np.abs(r - ro)) > maxerr: for _ in range(150): if np.sum(np.abs(r - ro)) <= maxerr: break ro = r.copy() # calculate each pagerank at a time for i in range(0, n): # in-links of state i Ai = np.array(A[:, i].todense())[:, 0] r[i] = ro.dot(Ai * s + Di * s + Ei * (1 - s)) weights = r / float(sum(r)) orderedWeights = np.argsort(weights) ReorderedWeights = np.flipud(orderedWeights) # m = max(weights) # ind = np.argmax(weights) listOfImages = list() for xx in range(k): listOfImages.append(images[ReorderedWeights[xx]]) # weightDict = {} # for xx in range(len(weights)): # weightDict[xx] = weights[xx] print(listOfImages) show_images(listOfImages, self.__database__) save_images(listOfImages, self.__database__, join(path, 'out'))
def run_scan(rotations, prefix, right=False): s = Scanner() print("Scanner initialized") print("Current laser is: " + "right" if right else "left") print("Rotations: " + str(rotations)) result = s.continuous(rotations, right=right) print("Images taken") raw_dir = 'raw_r' if right else 'raw_l' util.save_images(result, prefix, dir_name=os.path.join("img", prefix, raw_dir)) print("Images saved")
def process_continuous(self, images, num_rotations, prefix=None, right=False): processed = [] for i, img in enumerate(images): angle = 360.0 * i * num_rotations / len(images) processed.append(self.process_picture(img, angle, right)) print("Processing image {0} of {1}".format(i + 1, len(images))) if prefix: raw_dir = 'processed_r' if right else 'processed_l' util.save_images(processed, prefix, dir_name=os.path.join("img", prefix, raw_dir))
def process_pictures(self, pictures, prefix=None): # process pics if filter(lambda x: x is None, pictures): raise Exception('some pictures are null') processed = [] for i, picture in enumerate(pictures): #picture = resize_image(picture) #if we turn resize back on # don't forget to adjust back_wall_x processed.append(self.process_picture(picture, i * 360.0 / len(pictures))) print "processed %d; angle %f" % (i, i * 360.0 / len(pictures)) if prefix: util.save_images(processed, prefix, dir_name=os.path.join("img", prefix, "processed"))
def test(self): # check if attribute available # binary_attrsでtagを指定しているので長さは同じに if not len(self.binary_attrs) == self.n_label: print( "binary_attr length is wrong! The length should be {}".format( self.n_label)) return # variable initialize self.sess.run(tf.global_variables_initializer()) # load or not checkpoint if self.phase == 'test' and self.checkpoint_load(): print(" [*] before training, Load SUCCESS ") else: print(" [!] before training, no need to Load ") # [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save # data_dirから適当なサンプルを十持ってきている # 音声データだから連続的に適当な範囲を持ってくる test_files = glob(os.path.join(self.data_dir, 'test', '*')) testA_list = random.sample(test_files, 10) # get batch images and labels # self.attr_keys = ['Black_Hair','Blond_Hair','Brown_Hair', 'Male', 'Young','Mustache','Pale_Skin'] attrA = [float(i) for i in list(self.binary_attrs)] * len(testA_list) imgA, _ = preprocess_image(testA_list, testA_list, self.image_size, phase='test') dataA, _ = preprocess_input(imgA, imgA, attrA, attrA, self.image_size, self.n_label) # generate fakeB # 生成結果はfake_Bの中 feed = {self.real_A: dataA} fake_B = self.sess.run(self.fake_B, feed_dict=feed) # save samples test_file = os.path.join(self.test_dir, 'test.jpg') save_images(imgA, imgA, fake_B, self.image_size, test_file, num=10)
def test(ctx, enc, dec, test_data): global test_idx metric = mx.metric.MSE() samples = [] for images, labels in test_data: features = encode(enc, images, labels) images_out = decode(dec, features, labels) metric.update([images], [images_out]) idx = np.random.randint(images.shape[0]) samples.append(mx.nd.concat(images[idx], images_out[idx], dim=2)[0].asnumpy()) try: imgdir = '/tmp/mnist' save_images(samples[::2], imgdir, test_idx*1000) test_idx += 1 print("test images written to", imgdir) except Exception as e: print("writing images failed:", e) return metric.get()
def train(self, config): X = np.load(config.training_data) Prev = np.load(config.prev_data) ycond = np.zeros(shape=[self.batch_size, 13]) X, Prev = shuffle(X, Prev, random_state=0) d_optim = tf.train.AdamOptimizer(config.learning_rate, beta1=config.beta1) \ .minimize(self.d_loss, var_list=self.d_vars) g_optim = tf.train.AdamOptimizer(config.learning_rate, beta1=config.beta1) \ .minimize(self.g_loss, var_list=self.g_vars) self.sess.run(tf.global_variables_initializer()) self.g_sum = tf.summary.merge([ self.noise_sum, self.Df_sum, self.G_sum, self.d_loss_fake_sum, self.g_loss_sum ]) self.d_sum = tf.summary.merge([ self.noise_sum, self.D_sum, self.d_loss_real_sum, self.d_loss_sum ]) self.writer = tf.summary.FileWriter("./logs", self.sess.graph) counter = 0 start_time = time.time() for epoch in range(config.epochs): batch_idxs = len(X) // self.batch_size for idx in range(batch_idxs): batch_images = X[idx * self.batch_size:(idx + 1) * self.batch_size] prev_batch_images = Prev[idx * self.batch_size:(idx + 1) * self.batch_size] batch_labels = ycond.tolist() batch_noise = sample_Z([self.batch_size, 100]) _, summary_str = self.sess.run( [d_optim, self.d_sum], feed_dict={ self.data: batch_images, self.noise: batch_noise, self.cond1d: batch_labels, self.cond2d: prev_batch_images }) self.writer.add_summary(summary_str, counter) # Update G network _, summary_str = self.sess.run( [g_optim, self.g_sum], feed_dict={ self.data: batch_images, self.noise: batch_noise, self.cond1d: batch_labels, self.cond2d: prev_batch_images }) self.writer.add_summary(summary_str, counter) # Run g_optim twice to make sure that d_loss does not go to zero (different from paper) # We've tried to run more d_optim and g_optim, while getting a better result by running g_optim twice in this MidiNet version. _, summary_str = self.sess.run( [g_optim, self.g_sum], feed_dict={ self.data: batch_images, self.noise: batch_noise, self.cond1d: batch_labels, self.cond2d: prev_batch_images }) self.writer.add_summary(summary_str, counter) errD_fake = self.sess.run(self.d_loss_fake, feed_dict={ self.noise: batch_noise, self.cond1d: batch_labels, self.cond2d: prev_batch_images }) errD_real = self.sess.run(self.d_loss_real, feed_dict={ self.data: batch_images, self.cond1d: batch_labels }) errG = self.sess.run(self.g_loss, feed_dict={ self.data: batch_images, self.noise: batch_noise, self.cond1d: batch_labels, self.cond2d: prev_batch_images }) print("Epoch: [%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (epoch, idx, batch_idxs, time.time() - start_time, errD_fake+errD_real, errG)) samples, d_loss, g_loss = self.sess.run( [self.sample, self.d_loss, self.g_loss], feed_dict={ self.noise: batch_noise, self.data: batch_images, self.cond1d: batch_labels, self.cond2d: prev_batch_images }) #samples = (samples+1.)/2. save_images( samples[:5, :], [1, 5], '{}/train_{:02d}_{:04d}.png'.format(config.sample_dir, epoch, idx)) print("[Sample] d_loss: %.8f, g_loss: %.8f" % (d_loss, g_loss)) sound_sample = samples[0, :, :, 0] save_midi( sound_sample, '{}/train_{:02d}_{:04d}.mid'.format(config.sample_dir, epoch, idx)) print("Epoch: [%2d] time: %4.4f, d_loss: %.8f" \ % (epoch + 1, time.time() - start_time, (errD_fake+errD_real)))
def task4(self, args, path='.'): """ -task 4 --k # --imgs id1 id2 id3 """ if args.k == None or args.imgs == None: raise ValueError('K and Imgs must be defined for task 4.') k = int(args.k) imgs = list(args.imgs) # 6 2976167 83 38391649 299 135049429 # YOUR CODE HERE. G = self.__graph__.get_adjacency() images = self.__graph__.get_images() indexes = list() for x in imgs: indexes.append(images.index(x)) n = G.shape[0] s = 0.6 maxerr = 0.1 # transform G into markov matrix A A = csc_matrix(G, dtype=np.float) rsums = np.array(A.sum(1))[:, 0] ri, ci = A.nonzero() A.data /= rsums[ri] # bool array of sink states sink = rsums == 0 Ei = np.zeros(n) for ii in indexes: Ei[ii] = 1 / len(imgs) # Compute pagerank r until we converge ro, r = np.zeros(n), np.ones(n) # while np.sum(np.abs(r - ro)) > maxerr: for _ in range(100): if np.sum(np.abs(r - ro)) <= maxerr: break ro = r.copy() # calculate each pagerank at a time for i in range(0, n): # in-links of state i Ai = np.array(A[:, i].todense())[:, 0] # account for sink states Di = sink / float(n) # account for teleportation to state i r[i] = ro.dot(Ai * s + Di * s + Ei * (1 - s)) weights = r / float(sum(r)) orderedWeights = np.argsort(weights) ReorderedWeights = np.flipud(orderedWeights) # m = max(weights) # ind = np.argmax(weights) listOfImages = list() for xx in range(k): listOfImages.append(images[ReorderedWeights[xx]]) print(listOfImages) show_images(listOfImages, self.__database__) save_images(listOfImages, self.__database__, join(path, 'out'))
import os from arguments import Arguments from data import CreateDataLoader from models import create_model from util import save_images if __name__ == '__main__': args = Arguments().parse() data_loader = CreateDataLoader(args) dataset = data_loader.load_data() model = create_model(args) for i, data in enumerate(dataset): if i >= args.how_many: break model.set_input(data) model.test() visuals = model.get_current_visuals() img_path = model.get_image_paths() img_size = model.get_image_sizes() print('%04d: processing image... %s' % (i, img_path)) save_images(args.results_dir, visuals, img_path, size=img_size)
count = 0 every_n = 10 with tf.gfile.Open(args.output_file, 'w') as out_file: for filenames, images in util.load_images(args.input_dir, batch_shape, normalize=False, max_number=max_number): count += 1 if count % every_n == 0: start_time_loop = timeit.default_timer() # perform image denoising if not use_denoiser: pass elif use_denoiser == 'rand_uniform': images = images + 16 * np.random.uniform(-1, 1, images.shape) elif use_denoiser == 'rand_gaussian': images = images + 16 * np.random.normal(0, 0.7, images.shape) elif use_denoiser == 'quantization': images = np.round(images / quantization_bin) * quantization_bin else: raise ValueError("unsupported denoising method ", use_denoiser) images = util.normalize_image(images) if save_denoised: util.save_images(images, filenames, denoised_path) labels = sess.run(predicted_labels, feed_dict={img: images}) for filename, label in zip(filenames, labels): out_file.write('{0},{1}\n'.format(filename, label)) if count % every_n == 0: elapsed = timeit.default_timer() - start_time_loop print('processing speed ' + str(batch_shape[0]/elapsed) + ' samples per second') elapsed = timeit.default_timer() - start_time print('total elapsed time ' + str(elapsed) + ' second')
def generate(self): noise = np.array([np.random.uniform(-1, 1, 100) for _ in range(10)]) generated_images = self.model.predict(noise, verbose=0) util.save_images(generated_images, "generated_image.png")
def main(): parser = make_standard_parser( 'Train a GAN model on simple square images or Clevr two-object color images', arch_choices=arch_choices, skip_train=True, skip_val=True) parser.add_argument('--z_dim', type=int, default=10, help='Dimension of noise vector') parser.add_argument('--lr2', type=float, default=None, help='learning rate for generator') parser.add_argument('--feature_match', '-fm', action='store_true', help='use feature matching loss for generator.') parser.add_argument( '--feature_match_loss_weight', '-fmalpha', type=float, default=1.0, help='weight on the feature matching loss for generator.') parser.add_argument( '--pairedz', action='store_true', help='If True, pair the same z with a training batch each epoch') parser.add_argument( '--eval-train-every', type=int, default=0, help='evaluate whole training set every N epochs. 0 to disable.') args = parser.parse_args() args.skipval = True minibatch_size = args.minibatch train_style, val_style = ('', '') if args.nocolor else (colorama.Fore.BLUE, colorama.Fore.MAGENTA) evaltrain_style = '' if args.nocolor or args.eval_train_every <= 0 else colorama.Fore.CYAN black_divider = True if args.arch.startswith('clevr') else False # Get a TF session and set numpy and TF seeds sess = setup_session_and_seeds(args.seed, assert_gpu=not args.cpu) # 0. LOAD DATA if args.arch.startswith('simple'): fd = h5py.File('data/rectangle_4_uniform.h5', 'r') train_x = np.array(fd['train_imagegray'], dtype=float) / 255.0 # shape (2368, 64, 64, 1) val_x = np.array(fd['val_imagegray'], dtype=float) / 255.0 # shape (768, 64, 64, 1) train_x = np.concatenate((train_x, val_x), axis=0) # shape (3136, 64, 64, 1) elif args.arch.startswith('clevr'): (train_x, val_x) = load_sort_of_clevr() # shape (50000, 64, 64, 3) train_x = np.concatenate((train_x, val_x), axis=0) else: raise Exception('Unknown network architecture: %s' % args.arch) print 'Train data loaded: {} images, size {}'.format( train_x.shape[0], train_x.shape[1:]) #print 'Val data loaded: {} images, size {}'.format(val_x.shape[0], val_x.shape[1:]) #print 'Label dimension: {}'.format(val_y.shape[1:]) # 1. CREATE MODEL assert len(train_x.shape) == 4, "image data must be of 4 dimensions" image_h, image_w, image_c = train_x.shape[1], train_x.shape[ 2], train_x.shape[3] model = build_model(args, image_h, image_w, image_c) print 'All model weights:' summarize_weights(model.trainable_weights) print 'Model summary:' # model.summary() # TOREPLACE print 'Another model summary:' model.summarize_named(prefix=' ') print_trainable_warnings(model) # 2. COMPUTE GRADS AND CREATE OPTIMIZER lr_gen = args.lr2 if args.lr2 else args.lr if args.opt == 'sgd': d_opt = tf.train.MomentumOptimizer(args.lr, args.mom) g_opt = tf.train.MomentumOptimizer(lr_gen, args.mom) elif args.opt == 'rmsprop': d_opt = tf.train.RMSPropOptimizer(args.lr, momentum=args.mom) g_opt = tf.train.RMSPropOptimizer(lr_gen, momentum=args.mom) elif args.opt == 'adam': d_opt = tf.train.AdamOptimizer(args.lr, args.beta1, args.beta2) g_opt = tf.train.AdamOptimizer(lr_gen, args.beta1, args.beta2) # Optimize w.r.t all trainable params in the model all_vars = model.trainable_variables d_vars = [var for var in all_vars if 'discriminator' in var.name] g_vars = [var for var in all_vars if 'generator' in var.name] d_grads_and_vars = d_opt.compute_gradients( model.d_loss, d_vars, gate_gradients=tf.train.Optimizer.GATE_GRAPH) d_train_step = d_opt.apply_gradients(d_grads_and_vars) g_grads_and_vars = g_opt.compute_gradients( model.g_loss, g_vars, gate_gradients=tf.train.Optimizer.GATE_GRAPH) g_train_step = g_opt.apply_gradients(g_grads_and_vars) hist_summaries_traintest(model.d_real_logits, model.d_fake_logits) add_grads_and_vars_hist_summaries(d_grads_and_vars) add_grads_and_vars_hist_summaries(g_grads_and_vars) image_summaries_traintest(model.fake_images) # 3. OPTIONALLY SAVE OR LOAD VARIABLES (e.g. model params, model running # BN means, optimization momentum, ...) and then finalize initialization saver = tf.train.Saver( max_to_keep=None) if (args.output or args.load) else None if args.load: ckptfile, miscfile = args.load.split(':') # Restore values directly to graph saver.restore(sess, ckptfile) with gzip.open(miscfile) as ff: saved = pickle.load(ff) buddy = saved['buddy'] else: buddy = StatsBuddy(pretty_replaces=[('evaltrain_', ''), ( 'eval', '')]) if args.eval_train_every > 0 else StatsBuddy() buddy.tic() # call if new run OR resumed run tf.global_variables_initializer().run() # 4. SETUP TENSORBOARD LOGGING param_histogram_summaries = get_collection_intersection_summary( 'param_collection', 'orig_histogram') train_histogram_summaries = get_collection_intersection_summary( 'train_collection', 'orig_histogram') train_scalar_summaries = get_collection_intersection_summary( 'train_collection', 'orig_scalar') test_histogram_summaries = get_collection_intersection_summary( 'test_collection', 'orig_histogram') test_scalar_summaries = get_collection_intersection_summary( 'test_collection', 'orig_scalar') train_image_summaries = get_collection_intersection_summary( 'train_collection', 'orig_image') test_image_summaries = get_collection_intersection_summary( 'test_collection', 'orig_image') writer = None if args.output: mkdir_p(args.output) writer = tf.summary.FileWriter(args.output, sess.graph) # 5. TRAIN train_iters = (train_x.shape[0]) // minibatch_size if not args.skipval: val_iters = (val_x.shape[0]) // minibatch_size if args.ipy: print 'Embed: before train / val loop (Ctrl-D to continue)' embed() # 2. use same noise, eval on 100 samples and save G(z), np.random.seed() eval_batch_size = 100 eval_z = np.random.uniform(-1, 1, size=(eval_batch_size, args.z_dim)) while buddy.epoch < args.epochs + 1: # How often to log data def do_log_params(ep, it, ii): return True def do_log_val(ep, it, ii): return True def do_log_train(ep, it, ii): return (it < train_iters and it & it - 1 == 0 or it >= train_iters and it % train_iters == 0 ) # Log on powers of two then every epoch # 0. Log params if args.output and do_log_params( buddy.epoch, buddy.train_iter, 0) and param_histogram_summaries is not None: params_summary_str, = sess.run([param_histogram_summaries]) writer.add_summary(params_summary_str, buddy.train_iter) # 1. Evaluate generator by showing random generated results # Evaluate descriminator by showing seeing correct rate on generated and real (hold-out) results #assert(args.skipval), "only support training now" if not args.skipval: tic2() # use different noise, eval on larger number of samples and get # correct rate np.random.seed() val_z = np.random.uniform(-1, 1, size=(val_x.shape[0], args.z_dim)) with WithTimer('sess.run val iter', quiet=not args.verbose): feed_dict = { model.input_images: val_x, model.input_noise: val_z, learning_phase(): 0 } if 'input_labels' in model.named_keys(): feed_dict.update({model.input_labels: val_y}) val_corr_fake_bn0, val_corr_real_bn0 = sess.run( [model.correct_fake, model.correct_real], feed_dict=feed_dict) feed_dict[learning_phase()] = 1 val_corr_fake_bn1, val_corr_real_bn1 = sess.run( [model.correct_fake, model.correct_real], feed_dict=feed_dict) if args.output and do_log_val(buddy.epoch, buddy.train_iter, 0): fetch_dict = {} if test_image_summaries is not None: fetch_dict.update( {'test_image_summaries': test_image_summaries}) if test_scalar_summaries is not None: fetch_dict.update( {'test_scalar_summaries': test_scalar_summaries}) if test_histogram_summaries is not None: fetch_dict.update( {'test_histogram_summaries': test_histogram_summaries}) if fetch_dict: summary_strs = sess_run_dict(sess, fetch_dict, feed_dict=feed_dict) buddy.note_list([ 'correct_real_bn0', 'correct_fake_bn0', 'correct_real_bn1', 'correct_fake_bn1' ], [ val_corr_real_bn0, val_corr_fake_bn0, val_corr_real_bn1, val_corr_fake_bn1 ], prefix='val_') print( '%3d (ep %d) val: %s (%.3gs/ep)' % (buddy.train_iter, buddy.epoch, buddy.epoch_mean_pretty_re('^val_', style=val_style), toc2())) if args.output and do_log_val(buddy.epoch, buddy.train_iter, 0): log_scalars( writer, buddy.train_iter, { 'mean_%s' % name: value for name, value in buddy.epoch_mean_list_re('^val_') }, prefix='buddy') if test_image_summaries is not None: image_summary_str = summary_strs['test_image_summaries'] writer.add_summary(image_summary_str, buddy.train_iter) if test_scalar_summaries is not None: scalar_summary_str = summary_strs['test_scalar_summaries'] writer.add_summary(scalar_summary_str, buddy.train_iter) if test_histogram_summaries is not None: hist_summary_str = summary_strs['test_histogram_summaries'] writer.add_summary(hist_summary_str, buddy.train_iter) # In addition, evalutate 1000 more images np.random.seed() eval_more = np.random.uniform(-1, 1, size=(1000, args.z_dim)) feed_dict2 = { # (100,-) generated outside of loop to keep the same every round model.input_noise: eval_z, learning_phase(): 0 } eval_samples_bn0 = sess.run(model.fake_images, feed_dict=feed_dict2) feed_dict2[learning_phase()] = 1 eval_samples_bn1 = sess.run(model.fake_images, feed_dict=feed_dict2) # feed in 10 times because coordconv cannot handle too big of a batch for cc in range(10): eval_z2 = eval_more[cc * 100:(cc + 1) * 100, :] _eval_more_samples = sess.run( model.fake_images, feed_dict={ model.input_noise: eval_z2, # (1000,-) learning_phase(): 0 }) eval_more_samples = _eval_more_samples if cc == 0 else np.concatenate( (eval_more_samples, _eval_more_samples), axis=0) if args.output: mkdir_p('{}/fake_images'.format(args.output)) # eval_samples_bn*: e.g. (100, 64, 64, 3) save_images(eval_samples_bn0, [10, 10], '{}/fake_images/g_out_bn0_epoch_{}_iter_{}.png'.format( args.output, buddy.epoch, buddy.train_iter), black_divider=black_divider) save_images(eval_samples_bn1, [10, 10], '{}/fake_images/g_out_bn1_epoch_{}.png'.format( args.output, buddy.epoch), black_divider=black_divider) save_average_image( eval_more_samples, '{}/fake_images/g_out_averaged_epoch_{}_iter_{}.png'.format( args.output, buddy.epoch, buddy.train_iter)) # 2. Possiby Snapshot, possibly quit if args.output and args.snapshot_to and args.snapshot_every: snap_intermed = args.snapshot_every > 0 and buddy.train_iter % args.snapshot_every == 0 snap_end = buddy.epoch == args.epochs if snap_intermed or snap_end: # Snapshot save_path = saver.save( sess, '%s/%s_%04d.ckpt' % (args.output, args.snapshot_to, buddy.epoch)) print 'snappshotted model to', save_path with gzip.open( '%s/%s_misc_%04d.pkl.gz' % (args.output, args.snapshot_to, buddy.epoch), 'w') as ff: saved = {'buddy': buddy} pickle.dump(saved, ff) # snapshot sampled images too ff = h5py.File( '%s/sampled_images_%04d.h5' % (args.output, buddy.epoch), 'w') ff.create_dataset('eval_samples_bn0', data=eval_samples_bn0) ff.create_dataset('eval_samples_bn1', data=eval_samples_bn1) ff.create_dataset('eval_z', data=eval_z) ff.create_dataset('eval_z_more', data=eval_more) ff.create_dataset('eval_more_samples', data=eval_more_samples) ff.close() # 2. Possiby evaluate the training set if args.eval_train_every > 0: if buddy.epoch % args.eval_train_every == 0: tic2() for ii in xrange(train_iters): start_idx = ii * minibatch_size if args.pairedz: np.random.seed(args.seed + ii) else: np.random.seed() batch_z = np.random.uniform(-1, 1, size=(minibatch_size, args.z_dim)) batch_x = train_x[start_idx:start_idx + minibatch_size] batch_y = train_y[start_idx:start_idx + minibatch_size] feed_dict = { model.input_images: batch_x, # model.input_labels: batch_y, model.input_noise: batch_z, learning_phase(): 0, } if 'input_labels' in model.named_keys(): feed_dict.update({model.input_labels: val_y}) fetch_dict = model.trackable_dict() result_eval_train = sess_run_dict(sess, fetch_dict, feed_dict=feed_dict) buddy.note_weighted_list( batch_x.shape[0], model.trackable_names(), [ result_eval_train[k] for k in model.trackable_names() ], prefix='evaltrain_bn0_') feed_dict = { model.input_images: batch_x, # model.input_labels: batch_y, model.input_noise: batch_z, learning_phase(): 1, } if 'input_labels' in model.named_keys(): feed_dict.update({model.input_labels: val_y}) result_eval_train = sess_run_dict(sess, fetch_dict, feed_dict=feed_dict) buddy.note_weighted_list( batch_x.shape[0], model.trackable_names(), [ result_eval_train[k] for k in model.trackable_names() ], prefix='evaltrain_bn1_') if args.output: log_scalars(writer, buddy.train_iter, { 'batch_%s' % name: value for name, value in buddy.last_list_re( '^evaltrain_bn0_') }, prefix='buddy') log_scalars(writer, buddy.train_iter, { 'batch_%s' % name: value for name, value in buddy.last_list_re( '^evaltrain_bn1_') }, prefix='buddy') if args.output: log_scalars(writer, buddy.epoch, { 'mean_%s' % name: value for name, value in buddy.epoch_mean_list_re('^evaltrain_bn0_') }, prefix='buddy') log_scalars(writer, buddy.epoch, { 'mean_%s' % name: value for name, value in buddy.epoch_mean_list_re('^evaltrain_bn1_') }, prefix='buddy') print('%3d (ep %d) evaltrain: %s (%.3gs/ep)' % (buddy.train_iter, buddy.epoch, buddy.epoch_mean_pretty_re( '^evaltrain_bn0_', style=evaltrain_style), toc2())) print('%3d (ep %d) evaltrain: %s (%.3gs/ep)' % (buddy.train_iter, buddy.epoch, buddy.epoch_mean_pretty_re( '^evaltrain_bn1_', style=evaltrain_style), toc2())) if buddy.epoch == args.epochs: if args.ipy: print 'Embed: at end of training (Ctrl-D to exit)' embed() break # Extra pass at end: just report val stats and skip training # 3. Train on training set if args.shuffletrain: train_order = np.random.permutation(train_x.shape[0]) train_order2 = np.random.permutation(train_x.shape[0]) tic3() for ii in xrange(train_iters): tic2() start_idx = ii * minibatch_size if args.pairedz: np.random.seed(args.seed + ii) else: np.random.seed() batch_z = np.random.uniform(-1, 1, size=(minibatch_size, args.z_dim)) if args.shuffletrain: #batch_x = train_x[train_order[start_idx:start_idx + minibatch_size]] batch_x = train_x[sorted(train_order[start_idx:start_idx + minibatch_size].tolist())] if args.feature_match: assert args.shuffletrain, "feature matching loss requires shuffle train" batch_x2 = train_x[sorted( train_order2[start_idx:start_idx + minibatch_size].tolist())] if 'input_labels' in model.named_keys(): batch_y = train_y[sorted( train_order[start_idx:start_idx + minibatch_size].tolist())] else: batch_x = train_x[start_idx:start_idx + minibatch_size] if 'input_labels' in model.named_keys(): batch_y = train_y[start_idx:start_idx + minibatch_size] feed_dict = { model.input_images: batch_x, # model.input_labels: batch_y, model.input_noise: batch_z, learning_phase(): 1, } if 'input_labels' in model.named_keys(): feed_dict.update({model.input_labels: batch_y}) if 'input_images2' in model.named_keys(): feed_dict.update({model.input_images2: batch_x2}) fetch_dict = model.trackable_and_update_dict() if args.output and do_log_train(buddy.epoch, buddy.train_iter, ii): if train_histogram_summaries is not None: fetch_dict.update({ 'train_histogram_summaries': train_histogram_summaries }) if train_scalar_summaries is not None: fetch_dict.update( {'train_scalar_summaries': train_scalar_summaries}) if train_image_summaries is not None: fetch_dict.update( {'train_image_summaries': train_image_summaries}) with WithTimer('sess.run train iter', quiet=not args.verbose): result_train = sess_run_dict(sess, fetch_dict, feed_dict=feed_dict) # if result_train['d_loss'] < result_train['g_loss']: # #print 'Only train G' # sess.run(g_train_step, feed_dict=feed_dict) # else: # #print 'Train both D and G' # sess.run(d_train_step, feed_dict=feed_dict) # sess.run(g_train_step, feed_dict=feed_dict) # sess.run(g_train_step, feed_dict=feed_dict) sess.run(d_train_step, feed_dict=feed_dict) sess.run(g_train_step, feed_dict=feed_dict) sess.run(g_train_step, feed_dict=feed_dict) if do_log_train(buddy.epoch, buddy.train_iter, ii): buddy.note_weighted_list( batch_x.shape[0], model.trackable_names(), [result_train[k] for k in model.trackable_names()], prefix='train_') print('[%5d] [%2d/%2d] train: %s (%.3gs/i)' % (buddy.train_iter, buddy.epoch, args.epochs, buddy.epoch_mean_pretty_re('^train_', style=train_style), toc2())) if args.output and do_log_train(buddy.epoch, buddy.train_iter, ii): if train_histogram_summaries is not None: hist_summary_str = result_train[ 'train_histogram_summaries'] writer.add_summary(hist_summary_str, buddy.train_iter) if train_scalar_summaries is not None: scalar_summary_str = result_train['train_scalar_summaries'] writer.add_summary(scalar_summary_str, buddy.train_iter) if train_image_summaries is not None: image_summary_str = result_train['train_image_summaries'] writer.add_summary(image_summary_str, buddy.train_iter) log_scalars( writer, buddy.train_iter, { 'batch_%s' % name: value for name, value in buddy.last_list_re('^train_') }, prefix='buddy') if ii > 0 and ii % 100 == 0: print ' %d: Average iteration time over last 100 train iters: %.3gs' % ( ii, toc3() / 100) tic3() buddy.inc_train_iter() # after finished training a mini-batch buddy.inc_epoch() # after finished training whole pass through set if args.output and do_log_train(buddy.epoch, buddy.train_iter, 0): log_scalars( writer, buddy.train_iter, { 'mean_%s' % name: value for name, value in buddy.epoch_mean_list_re('^train_') }, prefix='buddy') print '\nFinal' print '%02d:%d val: %s' % (buddy.epoch, buddy.train_iter, buddy.epoch_mean_pretty_re('^val_', style=val_style)) print '%02d:%d train: %s' % (buddy.epoch, buddy.train_iter, buddy.epoch_mean_pretty_re('^train_', style=train_style)) print '\nfinal_stats epochs %g' % buddy.epoch print 'final_stats iters %g' % buddy.train_iter print 'final_stats time %g' % buddy.toc() for name, value in buddy.epoch_mean_list_all(): print 'final_stats %s %g' % (name, value) if args.output: writer.close() # Flush and close
def train(self): # Create fade-in (transition) parameters. step_pl = tf.placeholder(tf.float32, shape=None) alpha_transition_assign = self.alpha_transition.assign( step_pl / self.max_iterations) # Create Optimizers opti_D = tf.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.0, beta2=0.99).minimize( self.D_loss, var_list=self.d_vars) opti_G = tf.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.0, beta2=0.99).minimize( self.G_loss, var_list=self.g_vars) # Create Volume Transparency Stuff.. self.low_volumes = downscale(self.volumes, 2) self.low_volumes = upscale(self.low_volumes, 2) self.real_volumes = self.alpha_transition * self.volumes + ( 1 - self.alpha_transition) * self.low_volumes downscale_factor = 64 / (2**(self.progressive_depth + 1)) self.raw_volumes = tf.placeholder( tf.float32, [self.batch_size, 64, 64, 64, self.channel]) self.input_volumes = downscale(self.raw_volumes, downscale_factor) init = tf.global_variables_initializer() config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: # Personally have no idea what is being logged in this thing --andrew sess.run(init) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(self.log_dir, sess.graph) # No idea what the saving systems is like. TODO investigate --andrew. # I don't think you need to save and reload models if you create a crazy # system where you're only optimizing certain outputs/cost functions at # any one time. if self.progressive_depth != 1 and self.progressive_depth != 10: if self.transition: self.r_saver.restore(sess, self.input_model_path) self.rgb_saver.restore(sess, self.input_model_path) else: self.saver.restore(sess, self.input_model_path) step = 0 batch_num = 0 while step <= self.max_iterations: n_critic = 1 # Update Discriminator for i in range(n_critic): sample_latent = np.random.normal( size=[self.batch_size, self.latent_size]) # Not very Tensorflow aesthetic, here. realbatch_array = self.training_data.get_next_batch( batch_num=batch_num, zoom_level=self.zoom_level, batch_size=self.batch_size) realbatch_array = sess.run( self.input_volumes, feed_dict={self.raw_volumes: realbatch_array}) if self.transition and self.progressive_depth != 0: realbatch_array = sess.run( self.real_volumes, feed_dict={self.volumes: realbatch_array}) sess.run(opti_D, feed_dict={ self.volumes: realbatch_array, self.latent: sample_latent }) batch_num += 1 # Update Generator sess.run(opti_G, feed_dict={self.latent: sample_latent}) summary_str = sess.run(summary_op, feed_dict={ self.volumes: realbatch_array, self.latent: sample_latent }) summary_writer.add_summary(summary_str, step) # the alpha of fake_in process sess.run(alpha_transition_assign, feed_dict={step_pl: step}) if step % 40 == 0: D_loss, G_loss, D_origin_loss, alpha_tra = sess.run( [ self.D_loss, self.G_loss, self.D_origin_loss, self.alpha_transition ], feed_dict={ self.volumes: realbatch_array, self.latent: sample_latent }) print( "PG %d, step %d: D loss=%.7f G loss=%.7f, D_or loss=%.7f, opt_alpha_tra=%.7f" % (self.progressive_depth, step, D_loss, G_loss, D_origin_loss, alpha_tra)) if step % 400 == 0: save_images( realbatch_array[0:self.batch_size], [2, self.batch_size / 2], '{}/{:02d}_real.nii.gz'.format(self.samples_dir, step)) if self.transition and self.progressive_depth != 0: low_realbatch_array = sess.run( self.low_volumes, feed_dict={self.volumes: realbatch_array}) save_images( low_realbatch_array[0:self.batch_size], [2, self.batch_size / 2], '{}/{:02d}_real_lower.nii.gz'.format( self.samples_dir, step)) fake_image = sess.run(self.fake_images, feed_dict={ self.volumes: realbatch_array, self.latent: sample_latent }) save_images( fake_image[0:self.batch_size], [2, self.batch_size / 2], '{}/{:02d}_train.nii.gz'.format( self.samples_dir, step)) if np.mod(step, 4000) == 0 and step != 0: self.saver.save(sess, self.output_model_path) step += 1 save_path = self.saver.save(sess, self.output_model_path) print "Model saved in file: %s" % save_path tf.reset_default_graph()
def train(self, config): batch_size = config.batch_size learn_rate = config.learning_rate #################################### 定义优化器 # D的优化器 with tf.name_scope('D_train'): d_optimizer = tf.train.MomentumOptimizer( self.d_learn_rate, 0.5).minimize( self.d_loss, # global_step=global_step, var_list=[ t for t in tf.global_variables() if t.name.startswith('Discrim') ]) # G的优化器 with tf.name_scope('G_train'): g_optimizer = tf.train.MomentumOptimizer( self.g_learn_rate, 0.5).minimize( self.g_loss, # global_step=tf.Variable(0), var_list=[ t for t in tf.global_variables() if t.name.startswith('Generator') ]) import os if not os.path.exists("./checkpoint"): # 创建checkpoint存放文件夹 os.mkdir("./checkpoint") if not os.path.exists("./samples"): # 创建样本产生的文件夹 os.mkdir("./samples") writer = tf.summary.FileWriter(".//test", self.sess.graph) writer.add_graph(self.sess.graph) sum_var = tf.summary.merge_all() saver = tf.train.Saver() tf.global_variables_initializer().run() print("begin to get trainning data of MNIST") from tensorflow.examples.tutorials.mnist import input_data data = input_data.read_data_sets(config.datadir, validation_size=0) # 载入训练数据,不需要验证数据 data = data.train # 仅保留训练数据 batch_num = data.num_examples // batch_size images = [] for i in range(batch_num): images.append(data.next_batch(batch_size)[0]) print("data has prepared") sess = self.sess index = 0 print('begin to train GAN....') for step in range(config.epoch): # 使用G生成一批样本: d_loss_sum = 0.0 g_loss_sum = 0.0 for batch in range(1): batch_data = images[index] index = (index + 1) % batch_num # 训练D noise = random_data(batch_size, self.input_dim) d_loss_value, _, sum_v = sess.run( [self.d_loss, d_optimizer, sum_var], feed_dict={ self.input_real: batch_data, self.input_fake: noise, self.d_learn_rate: learn_rate, self.drop_possible: 0.5, }) d_loss_sum = d_loss_sum + d_loss_value writer.add_summary(sum_v, (step) * batch_num + batch) # 训练G g_loss_value, _ = sess.run( [self.g_loss, g_optimizer], feed_dict={ self.input_fake: noise, self.g_learn_rate: learn_rate, self.drop_possible: 1.0, }) g_loss_sum = g_loss_sum + g_loss_value noise = random_data(batch_size, self.input_dim) generate = sess.run(self.fake_data, feed_dict={ self.input_fake: noise, }) # print("before generate0",generate[0]) # print("before generate1",generate[1]) # generate = denormal_image(generate) if step == 5000: print("generate0", generate[0]) print("generate1", generate[1]) image1 = np.resize(generate[0], (28, 28)) image2 = np.resize(generate[1], (28, 28)) imsave("./samples/5000_1.jpg", image1) imsave("./samples/5000_2.jpg", image2) if step % 100 == 0: print("[%4d] GAN-d-loss: %.12f GAN-g-loss: %.12f" % (step, d_loss_sum / batch_num, g_loss_sum / batch_num)) # generate = denormal_image(generate[0:64]) generate = generate[0:64] # print("generate0",generate[0]) # print("generate1",generate[1]) save_images(generate, (8, 8), (28, 28, 1), "./samples/train_%d.jpg" % step) if step % 5000 == 0: saver.save(self.sess, os.path.join("./checkpoint", 'gan.ckpt')) print("check point saving...") noise = random_data(batch_size, self.input_dim) generate = sess.run(self.fake_data, feed_dict={ self.input_fake: noise, }) generate = denormal_image(generate[0:64]) save_images(generate, (8, 8), (28, 28, 1), "./samples/final.jpg") print("train finished" + "." * 10)
opt.num_threads = 0 opt.batch_size = 1 opt.serial_batches = True opt.no_flip = True opt.display_id = -1 dataset = create_dataset(opt) model = create_model(opt) model.setup(opt) web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.epoch)) webpage = util.HTML( web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch)) if opt.eval: model.eval() for i, data in enumerate(dataset): if i >= opt.num_test: break model.set_input(data) model.test() visuals = model.get_current_visuals() img_path = model.get_image_paths() if i % 5 == 0: print('processing (%04d)-th image... %s' % (i, img_path)) save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize) webpage.save()