def tower_loss(iteration, scope, input_keep_prob, keep_prob): # make inputs x = ring_net.inputs(CURRICULUM_BATCH_SIZE[iteration], CURRICULUM_SEQ[iteration]) # possible input dropout x_drop = tf.nn.dropout(x, input_keep_prob) # create and unrap network output_t, output_g, output_f = ring_net.unwrap(x_drop, keep_prob, CURRICULUM_SEQ[iteration]) # calc error _ = ring_net.loss(x, output_t, output_g, output_f) # error = tf.div(error, CURRICULUM_SEQ[iteration]) losses = tf.get_collection('losses', scope) # calc total loss total_loss = tf.add_n(losses, name='total_loss') # Compute the moving average of all individual losses and the total loss. #loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg') #loss_averages_op = loss_averages.apply(losses + [total_loss]) # Attach a scalar summary to all individual losses and the total loss; do the # same for the averaged version of the losses. #for l in losses + [total_loss]: # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training # session. This helps the clarity of presentation on tensorboard. # loss_name = re.sub('%s_[0-9]*/' % 'tower', '', l.op.name) # Name each loss as '(raw)' and name the moving average version of the loss # as the original loss name. # tf.scalar_summary(loss_name +' (raw)', l) # tf.scalar_summary(loss_name, loss_averages.average(l)) #with tf.control_dependencies([loss_averages_op]): # total_loss = tf.identity(total_loss) return total_loss
def evaluate(): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make inputs state, reward, action = ring_net.inputs(1, 15) # possible input dropout input_keep_prob = tf.placeholder("float") state_drop = tf.nn.dropout(state, input_keep_prob) # possible dropout inside keep_prob_encoding = tf.placeholder("float") keep_prob_lstm = tf.placeholder("float") # unwrap reward_2_o = [] # first step x_2, reward_2, hidden_state = ring_net.encode_compress_decode(state[:,0,:,:,:], action[:,1,:], None, keep_prob_encoding, keep_prob_lstm) tf.get_variable_scope().reuse_variables() # unroll for 9 more steps for i in xrange(9): x_2, reward_2, hidden_state = ring_net.encode_compress_decode(state[:,i+1,:,:,:], action[:,i+2,:], hidden_state, keep_prob_encoding, keep_prob_lstm) # now collect values reward_2_o.append(reward_2) for i in xrange(4): x_2, reward_2, hidden_state = ring_net.encode_compress_decode(x_2, action[:,i+11,:], hidden_state, keep_prob_encoding, keep_prob_lstm) reward_2_o.append(reward_2) reward_2_o = tf.pack(reward_2_o) reward_2_o = tf.transpose(reward_2_o, perm=[1,0,2]) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found from " + FLAGS.checkpoint_dir + ", this is an error") # Start que runner tf.train.start_queue_runners(sess=sess) reward_g_o, reward_o = sess.run([reward_2_o, reward],feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:1.0}) print(reward_g_o.shape) print(reward_o.shape) plt.figure(0) plt.plot(reward_g_o[0,:,0], label= "predicted reward") plt.plot(reward_o[0,10:,0], label= "reward") plt.title("reward vs step") plt.xlabel("step") plt.ylabel("reward") plt.legend() plt.savefig("paper_reward.png")
def evaluate(): """ Eval the system""" with tf.Graph().as_default(): # make inputs state_start, reward_start, action_start, = ring_net.inputs(1, 15) action_size = int(action_start.get_shape()[2]) action = tf.placeholder(tf.float32, (1, action_size)) # unwrap x_2_o = [] # first step x_2, reward_2, hidden_state = ring_net.encode_compress_decode(state_start[:,0,:,:,:], action_start[:,1,:], None, 1.0, 1.0) tf.get_variable_scope().reuse_variables() # unroll for 9 more steps for i in xrange(9): x_2, reward_2, hidden_state = ring_net.encode_compress_decode(state_start[:,i+1,:,:,:], action_start[:,i+2,:], hidden_state, 1.0, 1.0) # rename output_t x_1 = x_2 print(hidden_state) hidden_state_1 = hidden_state x_2, reward_2, hidden_state_2 = ring_net.encode_compress_decode(x_1, action, hidden_state_1, 1.0, 1.0) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found from " + FLAGS.checkpoint_dir + ", this is an error") # get frame tf.train.start_queue_runners(sess=sess) play_action = random_action(action_size) x_2_g, hidden_2_g = sess.run([x_1, hidden_state_1], feed_dict={}) # Play!!!! for step in xrange(100): print(step) #time.sleep(.5) # calc generated frame from t play_action = random_action(action_size) x_2_g, hidden_2_g = sess.run([x_2, hidden_state_2],feed_dict={x_1:x_2_g, hidden_state_1:hidden_2_g, action:play_action}) frame = np.uint8(np.minimum(np.maximum(0, x_2_g*255.0), 255)) frame = frame[0, :, :, :] video.write(frame) #frame = cv2.resize(frame, (500, 500)) #cv2.imshow('frame', frame) #cv2.waitKey(0) #if cv2.waitKey(1) & 0xFF == ord('q'): # break video.release() cv2.destroyAllWindows()
def evaluate(): """ Eval the system""" with tf.Graph().as_default(): # make inputs x = ring_net.inputs(1, NUM_FRAMES) # unwrap it keep_prob = tf.placeholder("float") output_t, output_g, output_f = ring_net.unwrap(x, keep_prob, NUM_FRAMES) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir + FLAGS.model + FLAGS.system) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found, this is an error") # start que runner tf.train.start_queue_runners(sess=sess) # eval ounce generated_seq, hidden_states, inputs = sess.run([output_g, output_f, x],feed_dict={keep_prob:1.0}) generated_seq = generated_seq[0] inputs = inputs[0] # make video hidden_im = np.zeros((100,100,3)) for step in xrange(NUM_FRAMES-1): # calc image from y_2 print(step) #hidden_im = np.zeros((100,100,3)) new_im = np.concatenate((generated_seq[step, :, :, 0:3].squeeze()/np.amax(generated_seq[step, :, :, 0:3]), inputs[step,:,:,0:3].squeeze()/np.amax(inputs[step,:,:,0:3]), generated_seq[step, :, :, 0:3].squeeze() - inputs[step, :, :, 0:3].squeeze()), axis=0) #hidden_im[0:32,0:32,0] = hidden_states[step,:].squeeze().reshape(32,32) #hidden_im[0:32,0:32,1] = hidden_states[step,:].squeeze().reshape(32,32) #hidden_im[0:32,0:32,2] = hidden_states[step,:].squeeze().reshape(32,32) new_im = np.uint8(np.abs(new_im * 255)) #hidden_im = np.uint8(np.abs(hidden_im * 255)) #print(new_im.shape) video.write(new_im) #video2.write(hidden_im) print('saved to ' + FLAGS.video_name) video.release() #video2.release() cv2.destroyAllWindows()
def evaluate(): """ Eval the system""" with tf.Graph().as_default(): # make inputs x = ring_net.inputs(1, 1) # unwrap it keep_prob = tf.placeholder("float") y_0 = unwrap_helper_test.encoding(x, keep_prob) x_1, y_1, hidden_state_1 = unwrap_helper_test.lstm_step(y_0, None, keep_prob) # set reuse to true tf.get_variable_scope().reuse_variables() x_2, y_2, hidden_state_2 = unwrap_helper_test.lstm_step(y_1, hidden_state_1, keep_prob) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir + FLAGS.model + FLAGS.system) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found, this is an error") # start que runner tf.train.start_queue_runners(sess=sess) # eval ounce generated_x_1, generated_y_1, generated_hidden_state_1 = sess.run([x_1, y_1, hidden_state_1],feed_dict={keep_prob:1.0}) new_im = np.uint8(np.abs(generated_x_1/np.amax(generated_x_1[0, :, :, :]) * 255)) video.write(new_im[0,:,:,:]) # make video for step in xrange(NUM_FRAMES-1): # continue to calc frames print(step) generated_x_1, generated_y_1, generated_hidden_state_1 = sess.run([x_2, y_2, hidden_state_2],feed_dict={keep_prob:1.0, y_1:generated_y_1, hidden_state_1:generated_hidden_state_1}) new_im = np.uint8(np.abs(generated_x_1/np.amax(generated_x_1[0, :, :, :]) * 255)) video.write(new_im[0,:,:,:]) print('saved to ' + FLAGS.video_name) video.release() #video2.release() cv2.destroyAllWindows()
def evaluate(): """ Eval the system""" with tf.Graph().as_default(): # make inputs x = ring_net.inputs(1, NUM_FRAMES) # unwrap it keep_prob = tf.placeholder("float") output_t, output_g, output_f = ring_net.unwrap(x, keep_prob, NUM_FRAMES) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir + FLAGS.model + FLAGS.system) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found, this is an error") # start que runner tf.train.start_queue_runners(sess=sess) # eval ounce generated_seq, inputs = sess.run([output_g, x],feed_dict={keep_prob:1.0}) generated_seq = generated_seq[0] inputs = inputs[0] # make video ims_generated = [] fig = plt.figure() for step in xrange(NUM_FRAMES): # calc image from y_2 print(step) new_im = np.concatenate((generated_seq[step, :, :, 2].squeeze()/np.amax(generated_seq[step, :, :, 2]), inputs[step,:,:,2].squeeze()/np.amax(inputs[step,:,:,2]), (generated_seq[step, :, :, 2].squeeze() - inputs[step,:,:,2].squeeze())), axis=0) ims_generated.append((plt.imshow(new_im),)) m_ani = animation.ArtistAnimation(fig, ims_generated, interval= 5000, repeat_delay=3000, blit=True) print(FLAGS.video_name) m_ani.save(FLAGS.video_name, writer=writer)
def train(): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make inputs state, reward, action = ring_net.inputs(4, 15) # possible input dropout input_keep_prob = tf.placeholder("float") state_drop = tf.nn.dropout(state, input_keep_prob) # possible dropout inside keep_prob_encoding = tf.placeholder("float") keep_prob_lstm = tf.placeholder("float") # unwrap x_2_o = [] # first step x_2, reward_2, hidden_state = ring_net.encode_compress_decode(state[:,0,:,:,:], action[:,1,:], None, keep_prob_encoding, keep_prob_lstm) tf.get_variable_scope().reuse_variables() # unroll for 9 more steps for i in xrange(9): x_2, reward_2, hidden_state = ring_net.encode_compress_decode(state[:,i+1,:,:,:], action[:,i+2,:], hidden_state, keep_prob_encoding, keep_prob_lstm) # now collect values x_2_o.append(x_2) for i in xrange(4): x_2, reward_2, hidden_state = ring_net.encode_compress_decode(x_2, action[:,i+11,:], hidden_state, keep_prob_encoding, keep_prob_lstm) x_2_o.append(x_2) tf.image_summary('images_gen_' + str(i), x_2) x_2_o = tf.pack(x_2_o) x_2_o = tf.transpose(x_2_o, perm=[1,0,2,3,4]) # error error = tf.nn.l2_loss(state[:,10:15,:,:,:] - x_2_o) tf.scalar_summary('loss', error) # train (hopefuly) train_op = ring_net.train(error, 1e-5) # List of all Variables variables = tf.all_variables() # Build a saver saver = tf.train.Saver(tf.all_variables(), max_to_keep=1) # Summary op summary_op = tf.merge_all_summaries() # Start running operations on the Graph. sess = tf.Session() # init from seq 1 model print("init from " + RESTORE_DIR) saver_restore = tf.train.Saver(variables) ckpt = tf.train.get_checkpoint_state(RESTORE_DIR) saver_restore.restore(sess, ckpt.model_checkpoint_path) # Start que runner tf.train.start_queue_runners(sess=sess) # Summary op graph_def = sess.graph.as_graph_def(add_shapes=True) summary_writer = tf.train.SummaryWriter(SAVE_DIR, graph_def=graph_def) for step in xrange(500000): t = time.time() _ , loss_value = sess.run([train_op, error],feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:1.0}) elapsed = time.time() - t assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step%100 == 0: print("loss value at " + str(loss_value)) print("time per batch is " + str(elapsed)) summary_str = sess.run(summary_op, feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:1.0}) summary_writer.add_summary(summary_str, step) if step%1000 == 0: checkpoint_path = os.path.join(SAVE_DIR, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print("saved to " + SAVE_DIR)
def evaluate(): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make inputs state, reward, action = ring_net.inputs(1, 15) # possible input dropout input_keep_prob = tf.placeholder("float") state_drop = tf.nn.dropout(state, input_keep_prob) # possible dropout inside keep_prob_encoding = tf.placeholder("float") keep_prob_lstm = tf.placeholder("float") # unwrap reward_2_o = [] # first step x_2, reward_2, hidden_state = ring_net.encode_compress_decode( state[:, 0, :, :, :], action[:, 1, :], None, keep_prob_encoding, keep_prob_lstm) tf.get_variable_scope().reuse_variables() # unroll for 9 more steps for i in xrange(9): x_2, reward_2, hidden_state = ring_net.encode_compress_decode( state[:, i + 1, :, :, :], action[:, i + 2, :], hidden_state, keep_prob_encoding, keep_prob_lstm) # now collect values reward_2_o.append(reward_2) for i in xrange(4): x_2, reward_2, hidden_state = ring_net.encode_compress_decode( x_2, action[:, i + 11, :], hidden_state, keep_prob_encoding, keep_prob_lstm) reward_2_o.append(reward_2) reward_2_o = tf.pack(reward_2_o) reward_2_o = tf.transpose(reward_2_o, perm=[1, 0, 2]) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found from " + FLAGS.checkpoint_dir + ", this is an error") # Start que runner tf.train.start_queue_runners(sess=sess) reward_g_o, reward_o = sess.run([reward_2_o, reward], feed_dict={ keep_prob_encoding: 1.0, keep_prob_lstm: 1.0, input_keep_prob: 1.0 }) print(reward_g_o.shape) print(reward_o.shape) plt.figure(0) plt.plot(reward_g_o[0, :, 0], label="predicted reward") plt.plot(reward_o[0, 10:, 0], label="reward") plt.title("reward vs step") plt.xlabel("step") plt.ylabel("reward") plt.legend() plt.savefig("paper_reward.png")
def train(iteration): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make inputs state, reward, action = ring_net.inputs(CURRICULUM_BATCH_SIZE[iteration], CURRICULUM_SEQ[iteration]) # possible input dropout input_keep_prob = tf.placeholder("float") state_drop = tf.nn.dropout(state, input_keep_prob) # possible dropout inside keep_prob_encoding = tf.placeholder("float") keep_prob_lstm = tf.placeholder("float") # create and unrap network output_f, output_t, output_g, output_reward, output_autoencoder = ring_net.unwrap(state_drop, action, keep_prob_encoding, keep_prob_lstm, CURRICULUM_SEQ[iteration], CURRICULUM_TRAIN_PEICE[iteration]) # calc error error = ring_net.loss(state, reward, output_f, output_t, output_g, output_reward, output_autoencoder, CURRICULUM_TRAIN_PEICE[iteration]) error = tf.div(error, CURRICULUM_SEQ[iteration]) # train (hopefuly) train_op = ring_net.train(error, CURRICULUM_LEARNING_RATE[iteration]) # List of all Variables variables = tf.all_variables() #for i, variable in enumerate(variables): # print '----------------------------------------------' # print variable.name[:variable.name.index(':')] # Build a saver saver = tf.train.Saver(tf.all_variables()) # Summary op summary_op = tf.merge_all_summaries() # Build an initialization operation to run below. if iteration == 0: init = tf.initialize_all_variables() # Start running operations on the Graph. sess = tf.Session() # init if this is the very time training if iteration == 0: print("init network from scratch") sess.run(init) # restore if iteration is not 0 if iteration != 0: variables_to_restore = tf.all_variables() autoencoder_variables = [variable for i, variable in enumerate(variables_to_restore) if ("compress" not in variable.name[:variable.name.index(':')]) and ("RNN" not in variable.name[:variable.name.index(':')])] rnn_variables = [variable for i, variable in enumerate(variables_to_restore) if ("compress" in variable.name[:variable.name.index(':')]) or ("RNN" in variable.name[:variable.name.index(':')])] ckpt = tf.train.get_checkpoint_state(SAVE_DIR) autoencoder_saver = tf.train.Saver(autoencoder_variables) print("restoring autoencoder part of network form " + ckpt.model_checkpoint_path) autoencoder_saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) if CURRICULUM_SEQ[iteration-1] == 1: print("init compression part of network from scratch") rnn_init = tf.initialize_variables(rnn_variables) sess.run(rnn_init) else: rnn_saver = tf.train.Saver(rnn_variables) print("restoring compression part of network") rnn_saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) # Start que runner tf.train.start_queue_runners(sess=sess) # Summary op graph_def = sess.graph.as_graph_def(add_shapes=True) summary_writer = tf.train.SummaryWriter(SAVE_DIR, graph_def=graph_def) for step in xrange(CURRICULUM_STEPS[iteration]): t = time.time() _ , loss_value = sess.run([train_op, error],feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:.8}) elapsed = time.time() - t assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step%100 == 0: print("loss value at " + str(loss_value)) print("time per batch is " + str(elapsed)) summary_str = sess.run(summary_op, feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:.8}) summary_writer.add_summary(summary_str, step) if step%1000 == 0: checkpoint_path = os.path.join(SAVE_DIR, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print("saved to " + SAVE_DIR)
def train(): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make inputs state, reward, action = ring_net.inputs(4, 15) # possible input dropout input_keep_prob = tf.placeholder("float") state_drop = tf.nn.dropout(state, input_keep_prob) # possible dropout inside keep_prob_encoding = tf.placeholder("float") keep_prob_lstm = tf.placeholder("float") # unwrap x_2_o = [] # first step x_2, reward_2, hidden_state = ring_net.encode_compress_decode( state[:, 0, :, :, :], action[:, 1, :], None, keep_prob_encoding, keep_prob_lstm) tf.get_variable_scope().reuse_variables() # unroll for 9 more steps for i in xrange(9): x_2, reward_2, hidden_state = ring_net.encode_compress_decode( state[:, i + 1, :, :, :], action[:, i + 2, :], hidden_state, keep_prob_encoding, keep_prob_lstm) # now collect values x_2_o.append(x_2) for i in xrange(4): x_2, reward_2, hidden_state = ring_net.encode_compress_decode( x_2, action[:, i + 11, :], hidden_state, keep_prob_encoding, keep_prob_lstm) x_2_o.append(x_2) tf.image_summary('images_gen_' + str(i), x_2) x_2_o = tf.pack(x_2_o) x_2_o = tf.transpose(x_2_o, perm=[1, 0, 2, 3, 4]) # error error = tf.nn.l2_loss(state[:, 10:15, :, :, :] - x_2_o) tf.scalar_summary('loss', error) # train (hopefuly) train_op = ring_net.train(error, 1e-5) # List of all Variables variables = tf.all_variables() # Build a saver saver = tf.train.Saver(tf.all_variables(), max_to_keep=1) # Summary op summary_op = tf.merge_all_summaries() # Start running operations on the Graph. sess = tf.Session() # init from seq 1 model print("init from " + RESTORE_DIR) saver_restore = tf.train.Saver(variables) ckpt = tf.train.get_checkpoint_state(RESTORE_DIR) saver_restore.restore(sess, ckpt.model_checkpoint_path) # Start que runner tf.train.start_queue_runners(sess=sess) # Summary op graph_def = sess.graph.as_graph_def(add_shapes=True) summary_writer = tf.train.SummaryWriter(SAVE_DIR, graph_def=graph_def) for step in xrange(500000): t = time.time() _, loss_value = sess.run([train_op, error], feed_dict={ keep_prob_encoding: 1.0, keep_prob_lstm: 1.0, input_keep_prob: 1.0 }) elapsed = time.time() - t assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step % 100 == 0: print("loss value at " + str(loss_value)) print("time per batch is " + str(elapsed)) summary_str = sess.run(summary_op, feed_dict={ keep_prob_encoding: 1.0, keep_prob_lstm: 1.0, input_keep_prob: 1.0 }) summary_writer.add_summary(summary_str, step) if step % 1000 == 0: checkpoint_path = os.path.join(SAVE_DIR, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print("saved to " + SAVE_DIR)
def train(iteration): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make inputs state, reward, action = ring_net.inputs(CURRICULUM_BATCH_SIZE[iteration], CURRICULUM_SEQ[iteration]) # possible input dropout input_keep_prob = tf.placeholder("float") state_drop = tf.nn.dropout(state, input_keep_prob) # possible dropout inside keep_prob_encoding = tf.placeholder("float") keep_prob_lstm = tf.placeholder("float") # create and unrap network output_f, output_t, output_g, output_reward, output_autoencoder = ring_net.unwrap(state_drop, action, keep_prob_encoding, keep_prob_lstm, CURRICULUM_SEQ[iteration], CURRICULUM_TRAIN_PEICE[iteration]) # calc error error = ring_net.loss(state, reward, output_f, output_t, output_g, output_reward, output_autoencoder, CURRICULUM_TRAIN_PEICE[iteration]) error = tf.div(error, CURRICULUM_SEQ[iteration]) # train (hopefuly) train_op = ring_net.train(error, CURRICULUM_LEARNING_RATE[iteration]) # List of all Variables variables = tf.all_variables() #for i, variable in enumerate(variables): # print '----------------------------------------------' # print variable.name[:variable.name.index(':')] # Build a saver saver = tf.train.Saver(tf.all_variables()) # Summary op summary_op = tf.merge_all_summaries() # Start running operations on the Graph. sess = tf.Session() # restore if iteration is not 0 variables_to_restore = tf.all_variables() autoencoder_variables = [variable for i, variable in enumerate(variables_to_restore) if ("compress" not in variable.name[:variable.name.index(':')]) and ("RNN" not in variable.name[:variable.name.index(':')])] rnn_variables = [variable for i, variable in enumerate(variables_to_restore) if ("compress" in variable.name[:variable.name.index(':')]) or ("RNN" in variable.name[:variable.name.index(':')])] if iteration == 0: ckpt = tf.train.get_checkpoint_state(LOAD_DIR) else: ckpt = tf.train.get_checkpoint_state(SAVE_DIR) autoencoder_saver = tf.train.Saver(autoencoder_variables) print("restoring autoencoder part of network form " + ckpt.model_checkpoint_path) autoencoder_saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) if iteration == 0: print("init compression part of network from scratch") rnn_init = tf.initialize_variables(rnn_variables) sess.run(rnn_init) else: rnn_saver = tf.train.Saver(rnn_variables) print("restoring compression part of network") rnn_saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) # Start que runner tf.train.start_queue_runners(sess=sess) # Summary op graph_def = sess.graph.as_graph_def(add_shapes=True) summary_writer = tf.train.SummaryWriter(SAVE_DIR, graph_def=graph_def) for step in xrange(CURRICULUM_STEPS[iteration]): t = time.time() _ , loss_value = sess.run([train_op, error],feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:.8}) elapsed = time.time() - t assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step%100 == 0: print("loss value at " + str(loss_value)) print("time per batch is " + str(elapsed)) summary_str = sess.run(summary_op, feed_dict={keep_prob_encoding:1.0, keep_prob_lstm:1.0, input_keep_prob:.8}) summary_writer.add_summary(summary_str, step) if step%1000 == 0: checkpoint_path = os.path.join(SAVE_DIR, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print("saved to " + SAVE_DIR)
def evaluate(): """ Eval the system""" with tf.Graph().as_default(): # make inputs state_start, reward_start, action_start, = ring_net.inputs(1, 15) action_size = int(action_start.get_shape()[2]) action = tf.placeholder(tf.float32, (1, action_size)) # unwrap x_2_o = [] # first step x_2, reward_2, hidden_state = ring_net.encode_compress_decode( state_start[:, 0, :, :, :], action_start[:, 1, :], None, 1.0, 1.0) tf.get_variable_scope().reuse_variables() # unroll for 9 more steps for i in xrange(9): x_2, reward_2, hidden_state = ring_net.encode_compress_decode( state_start[:, i + 1, :, :, :], action_start[:, i + 2, :], hidden_state, 1.0, 1.0) # rename output_t x_1 = x_2 print(hidden_state) hidden_state_1 = hidden_state x_2, reward_2, hidden_state_2 = ring_net.encode_compress_decode( x_1, action, hidden_state_1, 1.0, 1.0) # restore network variables_to_restore = tf.all_variables() saver = tf.train.Saver(variables_to_restore) sess = tf.Session() ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) else: print("no chekcpoint file found from " + FLAGS.checkpoint_dir + ", this is an error") # get frame tf.train.start_queue_runners(sess=sess) play_action = random_action(action_size) x_2_g, hidden_2_g = sess.run([x_1, hidden_state_1], feed_dict={}) # Play!!!! for step in xrange(100): print(step) #time.sleep(.5) # calc generated frame from t play_action = random_action(action_size) x_2_g, hidden_2_g = sess.run([x_2, hidden_state_2], feed_dict={ x_1: x_2_g, hidden_state_1: hidden_2_g, action: play_action }) frame = np.uint8(np.minimum(np.maximum(0, x_2_g * 255.0), 255)) frame = frame[0, :, :, :] video.write(frame) #frame = cv2.resize(frame, (500, 500)) #cv2.imshow('frame', frame) #cv2.waitKey(0) #if cv2.waitKey(1) & 0xFF == ord('q'): # break video.release() cv2.destroyAllWindows()
def train(iteration): """Train ring_net for a number of steps.""" with tf.Graph().as_default(): # make dynamic system #if FLAGS.system == "cannon": # k = cn.Cannon() # make inputs x = ring_net.inputs(CURRICULUM_BATCH_SIZE[iteration], CURRICULUM_SEQ[iteration]) # possible input dropout input_keep_prob = tf.placeholder("float") x_drop = tf.nn.dropout(x, input_keep_prob) # possible dropout inside keep_prob = tf.placeholder("float") # create and unrap network output_t, output_g, output_f = ring_net.unwrap(x_drop, keep_prob, CURRICULUM_SEQ[iteration]) # calc error error = ring_net.loss(x, output_t, output_g, output_f) error = tf.div(error, CURRICULUM_SEQ[iteration]) # train hopefuly train_op = ring_net.train(error, CURRICULUM_LEARNING_RATE[iteration]) # List of all Variables variables = tf.all_variables() # Build a saver saver = tf.train.Saver(tf.all_variables()) for i, variable in enumerate(variables): print '----------------------------------------------' print variable.name[:variable.name.index(':')] # Summary op summary_op = tf.merge_all_summaries() # Build an initialization operation to run below. if iteration == 0: init = tf.initialize_all_variables() # Start running operations on the Graph. sess = tf.Session() # init if this is the very time training if iteration == 0: print("init network from scratch") sess.run(init) # restore if iteration is not 0 if iteration != 0: variables_to_restore = tf.all_variables() autoencoder_variables = [variable for i, variable in enumerate(variables_to_restore) if "RNNCell" not in variable.name[:variable.name.index(':')]] rnn_variables = [variable for i, variable in enumerate(variables_to_restore) if "RNNCell" in variable.name[:variable.name.index(':')]] ckpt = tf.train.get_checkpoint_state(FLAGS.train_dir + FLAGS.model + FLAGS.system) autoencoder_saver = tf.train.Saver(autoencoder_variables) print("restoring autoencoder part of network form " + ckpt.model_checkpoint_path) autoencoder_saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) if CURRICULUM_SEQ[iteration-1] == 1: print("init rnn part of network from scratch") rnn_init = tf.initialize_variables(rnn_variables) sess.run(rnn_init) else: rnn_saver = tf.train.Saver(rnn_variables) print("restoring rnn part of network") rnn_saver.restore(sess, ckpt.model_checkpoint_path) print("restored file from " + ckpt.model_checkpoint_path) # Start que runner tf.train.start_queue_runners(sess=sess) # Summary op graph_def = sess.graph.as_graph_def(add_shapes=True) summary_writer = tf.train.SummaryWriter(FLAGS.train_dir + FLAGS.model + FLAGS.system, graph_def=graph_def) for step in xrange(CURRICULUM_STEPS[iteration]): t = time.time() _ , loss_value = sess.run([train_op, error],feed_dict={keep_prob:0.9, input_keep_prob:.8}) elapsed = time.time() - t assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step%100 == 0: summary_str = sess.run(summary_op, feed_dict={keep_prob:0.9, input_keep_prob:.8}) summary_writer.add_summary(summary_str, step) if step%1000 == 0: checkpoint_path = os.path.join(FLAGS.train_dir + FLAGS.model + FLAGS.system, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print("saved to " + FLAGS.train_dir + FLAGS.model + FLAGS.system) print("loss value at " + str(loss_value)) print("time per batch is " + str(elapsed))