def test_block_inversion(): batch_size = 13 height, width = 32, 32 num_channel = 3 block = InvertibleBlock( in_shape=(batch_size, height, width, num_channel), stride=2, num_channel=num_channel, # channel of intermediate layers coeff=0.97, power_iter=1, num_trace_samples=2, num_series_terms=2, activation=tf.nn.elu, use_sn=True, use_actnorm=False) x = tf.random.normal(shape=(batch_size, height, width, num_channel)) out, trace = block(x) x_inverse = block.inverse(out) diff = tf.reduce_mean(tf.abs(x - x_inverse)) sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) _diff = sess.run(diff) print("Inversion difference is: {}".format(_diff))
def process(): tf.disable_eager_execution() sess = tf.InteractiveSession(graph=tf.Graph()) ConvRT_model = hub.Module("../Sentence_Encoder/Embeddings/ConvRT/") USE_model = hub.load('../Sentence_Encoder/Embeddings/USE_QA/') sess.run(tf.tables_initializer()) sess.run(tf.global_variables_initializer()) with open("Processed_Scripts/Bot_Profile.pkl", "rb") as fp: bot_profile = pickle.load(fp) with open("Processed_Scripts/Chatterbot.pkl", "rb") as fp: chatterbot = pickle.load(fp) bot_queries = [k for k, v in bot_profile.items()] bot_contexts = ["" for k, v in bot_profile.items()] chatterbot_queries = [k for k, v in chatterbot.items()] chatterbot_contexts = ["" for k, v in chatterbot.items()] embedded_bot_queries = encode(sess, bot_queries, bot_contexts, USE_model, ConvRT_model) embedded_chatterbot_queries = encode(sess, chatterbot_queries, chatterbot_contexts, USE_model, ConvRT_model) with open("Processed_Scripts/embedded_bot_queries.pkl", "wb") as fp: pickle.dump(embedded_bot_queries, fp) with open("Processed_Scripts/embedded_chatterbot_queries.pkl", "wb") as fp: pickle.dump(embedded_chatterbot_queries, fp)
def playGame(): sess=tf.InteractiveSession() s, readout, h_fc1 = createNetwork("m1") s_2, readout_2, h_fc1_2 = createNetwork("m2") trainNetwork(s, readout, s_2, readout_2, sess )
def init_session(self, device_id=0): config = tf.ConfigProto() config.gpu_options.allow_growth = True ## just for use the necesary memory of GPU config.gpu_options.visible_device_list = str(device_id) ## this values depends of numbers of GPUs print("Session and graph initialized.") self.sess = tf.InteractiveSession(config=config, graph=self)
def test_build_graph(self, dataset_name, regression): """Test whether build_graph works as expected.""" data_x, data_y, _ = data_utils.load_dataset(dataset_name) data_gen = data_utils.split_training_dataset( data_x, data_y, n_splits=5, stratified=not regression) (x_train, y_train), (x_validation, y_validation) = next(data_gen) sess = tf.InteractiveSession() graph_tensors_and_ops, metric_scores = graph_builder.build_graph( x_train=x_train, y_train=y_train, x_test=x_validation, y_test=y_validation, activation='exu', learning_rate=1e-3, batch_size=256, shallow=True, regression=regression, output_regularization=0.1, dropout=0.1, decay_rate=0.999, name_scope='model', l2_regularization=0.1) # Run initializer ops sess.run(tf.global_variables_initializer()) sess.run([ graph_tensors_and_ops['iterator_initializer'], graph_tensors_and_ops['running_vars_initializer'] ]) for _ in range(2): sess.run(graph_tensors_and_ops['train_op']) self.assertIsInstance(metric_scores['train'](sess), float) sess.close()
def test_net(): print(bcolors.G + "Task : test\n" + bcolors.END) student = lenet() pred = tf.nn.softmax(student) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1.0) sess = tf.InteractiveSession(config=tf.ConfigProto( gpu_options=gpu_options)) init = tf.initialize_all_variables() sess.run(init) with tf.device('/gpu:0'): saver = tf.train.Saver() model_file = tf.train.latest_checkpoint(model) saver.restore(sess, model_file) mean = cal_mean() data, label = read_cifar10('test') total = 0 correct = 0 begin = time.time() for j in range(len(data) // batch_size): batch_x = data[j * batch_size:(j + 1) * batch_size] - mean prob = sess.run([pred], feed_dict={ x: batch_x, y: np.ones((batch_size)), keep_prob: 1.0 }) if np.argmax(prob[0]) == label[j]: correct += 1 total += 1 #print(("acc = %f . %d/%d"%(float(correct)/total, correct, total)) end = time.time() print("acc = %f . %d/%d. Computing time = %f seconds" % (float(correct) / total, correct, total, end - begin))
def test_iresnet(): np.random.seed(2019) batch_size = 2 input_size = 8 channels = 3 input_shape = (batch_size, input_size, input_size, channels) x_np = np.random.rand(*input_shape).astype("float32") x = tf.placeholder(tf.float32, [None, input_size, input_size, channels]) net = IResNet( in_shape=input_shape, block_list=[32, 32, 32], #[1, 2, 3], stride_list=[1, 2, 2], channel_list=[32, 32, 32],#[2, 3, 5], num_trace_samples=4, num_series_terms=3, coeff=0.97, power_iter=2) log_prob_z, trace, loss, z = net(x) a = net.inverse(z) sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) _log_prob_z, _trace, _loss, _z, _a = sess.run([log_prob_z, trace, loss, z, a], feed_dict={x: x_np}) print("Loss is: {}".format(_loss)) print("Trace is: {}".format(_trace)) print("Log prob is: {}".format(_log_prob_z)) print("z shape is: {}".format(z.shape)) print("a shape is {}".format(a.shape))
def test_layer_with_activation_after_bn_different_activation_before_bn( self): """Tests the option to use activation before or after batchnorm.""" tf.reset_default_graph() model_config = make_layerwise_model_config() act_fn = tf.ones_like layer_act_after = layerwise.ConvLayer( name='test_layer_activation_after', model_config=model_config, act_fn=act_fn, act_after_bn=True) layer_act_before = layerwise.ConvLayer( name='test_layer_activation_before', model_config=model_config, act_fn=act_fn, act_after_bn=False) images = tf.random.normal((100, 28, 28, 3)) out_after = layer_act_after(images) out_before = layer_act_before(images) sess = tf.InteractiveSession() sess.run(tf.initializers.global_variables()) self.assertAllEqual( out_after, tf.ones_like(out_after), 'When evaluating layerwise.ConvLayer activation after' 'BatchNorm was not computed properly.') self.assertAllEqual( out_before, tf.zeros_like(out_before), 'When evaluating layerwise.ConvLayer activation before' 'BatchNorm was not computed properly.')
def save_all(): import tensorflow as tf import tensorflow.compat.v1 as tf1 import tqdm sess = tf1.InteractiveSession() image_ph = tf.compat.v1.placeholder(dtype=tf.uint8, shape=(None, None, 3)) encode_op = tf.image.encode_png(image_ph) maketree('mnistimg/mnist') with open('mnistimg/mnist-validation.txt', 'w') as filenames: for i in tqdm.trange(len(test_images)): label = test_labels[i] image = test_images[i] path = "mnist/validation/{}/{}.png".format(label, i) filenames.write(path + '\n') filenames.flush() path = "mnistimg/" + path maketree(os.path.dirname(path)) data = sess.run(encode_op, {image_ph: as_rgb(image)}) with open(path, "wb") as f: f.write(data) with open('mnistimg/mnist-train.txt', 'w') as filenames: for i in tqdm.trange(len(train_images)): label = train_labels[i] image = train_images[i] path = "mnist/train/{}/{}.png".format(label, i) filenames.write(path + '\n') filenames.flush() path = "mnistimg/" + path maketree(os.path.dirname(path)) data = sess.run(encode_op, {image_ph: as_rgb(image)}) with open(path, "wb") as f: f.write(data)
def main(): tf.compat.v1.disable_eager_execution() # data = tf.keras.datasets.mnist # (x_train, y_train), (x_test, y_test) = data.load_data() mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # plt.imshow(x_train[1], cmap="binary") # plt.show() sess = tfc.InteractiveSession() x = tfc.placeholder("float", shape=[None, 784]) y_ = tfc.placeholder("float", shape=[None, 10]) W = tf.Variable(tf.zeros([784, 10])) b = tf.Variable(tf.zeros([10])) sess.run(tfc.initialize_all_variables()) y = tf.nn.softmax(tf.matmul(x, W) + b) cross_entropy = -tf.reduce_sum(y_ * tfc.log(y)) train_step = tfc.train.GradientDescentOptimizer(0.01).minimize( cross_entropy) for i in range(1000): batch = mnist.train.next_batch(50) train_step.run(feed_dict={x: batch[0], y_: batch[1]}) correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print( "测试集的正确率为", accuracy.eval(feed_dict={ x: mnist.test.images, y_: mnist.test.labels }))
def __init__(self, observation_width, observation_height, action_space, model_file, log_file): # the state is the input vector of network, in this env, it has four dimensions self.state_dim = observation_width * observation_height self.state_w = observation_width self.state_h = observation_height # the action is the output vector and it has two dimensions self.action_dim = action_space # init experience replay, the deque is a list that first-in & first-out self.replay_buffer = deque() # you can create the network by the two parameters self.create_Q_network() # after create the network, we can define the training methods self.create_updating_method() # set the value in choose_action self.epsilon = INITIAL_EPSILON self.model_path = model_file + "/save_model.ckpt" self.model_file = model_file self.log_file = log_file # 因为保存的模型名字不太一样,只能检查路径是否存在 # Init session self.session = tf.InteractiveSession() if os.path.exists(self.model_file): print("model exists , load model\n") self.saver = tf.train.Saver() self.saver.restore(self.session, self.model_path) else: print("model don't exists , create new one\n") self.session.run(tf.global_variables_initializer()) self.saver = tf.train.Saver() # init # 只有把框图保存到文件中,才能加载到浏览器中观看 self.writer = tf.summary.FileWriter(self.log_file, self.session.graph) ####### 路径中不要有中文字符,否则加载不进来 ########### # tensorboard --logdir=logs_gpu --host=127.0.0.1 self.merged = tf.summary.merge_all()
def create_session(self, improve_by=5, min_epoch=10): self.objs['saver'] = tf.train.Saver() # self.objs['sess'] = tf.Session(config = self.session_config) self.objs['sess'] = tf.InteractiveSession() self.objs['sess'].run(tf.global_variables_initializer()) # (Disabled) Early Stopping # self.objs['es'] = utils.EarlyStopping( # self.objs['sess'], # self.objs['saver'], # save_dir = "saved_seed%d" % self.seed, # improve_by = improve_by, # min_epoch = min_epoch # ) if self.feature_extractor_needed: if not os.path.exists("vgg16_cifar100"): print("Pretrained model doesnt exist for VGG16") print("Run cifar100.py first") exit(0) else: reqd_variables = tf.get_collection( tf.GraphKeys.GLOBAL_VARIABLES, scope="feature_extractor") feature_extractor_saver = tf.train.Saver(reqd_variables) print("Restoring feature extractor variables") feature_extractor_saver.restore(self.objs['sess'], "vgg16_cifar100/saved.ckpt") print("Done")
def initialize_model(self): """ Initialize model structure and set cost function and training method """ self.y_pred = self.build_extractor(self.X) # weighted cross entropy self.cost_extractor = cross_entropy_with_clip(self.Y, self.y_pred, self.classweights) # Do include the following to update BN parameters # https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): self.train_op_extractor = tf.train.AdamOptimizer( 0.001, beta1=0.9).minimize(self.cost_extractor) # start session self.sess = tf.InteractiveSession() tf.global_variables_initializer().run() # saver self.saver = tf.train.Saver() # summary tf.summary.scalar("cross_entropy", self.cost_extractor) self.summary_op = tf.summary.merge_all() self.writer = tf.summary.FileWriter(self.logdir, self.sess.graph)
def __init__(self, state_size, window_size, trend, skip, batch_size): self.state_size = state_size self.window_size = window_size self.half_window = window_size // 2 self.trend = trend self.skip = skip self.action_size = 3 self.batch_size = batch_size self.memory = deque(maxlen=1000) self.inventory = [] self.gamma = 0.95 self.epsilon = 0.5 self.epsilon_min = 0.01 self.epsilon_decay = 0.999 tf.reset_default_graph() self.sess = tf.InteractiveSession() self.X = tf.placeholder(tf.float32, [None, self.state_size]) self.Y = tf.placeholder(tf.float32, [None, self.action_size]) feed = tf.layers.dense( self.X, 256, activation=tf.nn.relu) # 1 hidden layer with 256 nodes ## one hidden layer, dimension hidden layer = 10, dimension output layer = 1 # hidden = tf.layers.dense(tf_x, 10, tf.nn.relu) # output = tf.layers.dense(hidden, 1, tf.nn.relu) self.logits = tf.layers.dense( feed, self.action_size ) # output layer with 3 nodes corresponding to output node self.cost = tf.reduce_mean(tf.square(self.Y - self.logits)) # L2 cost function self.optimizer = tf.train.GradientDescentOptimizer(1e-5).minimize( self.cost) # standard GD optimizer self.sess.run(tf.global_variables_initializer()) # initialized session
def _load_frozen_graph(self, frozen_graph_path): trt_graph = tf.GraphDef() with open(frozen_graph_path, 'rb') as f: trt_graph.ParseFromString(f.read()) self.graph = tf.Graph() with self.graph.as_default(): self.output_node = tf.import_graph_def( trt_graph, return_elements=[ 'detection_boxes:0', 'detection_classes:0', 'detection_scores:0', 'num_detections:0', 'raw_outputs/lstm_c:0', 'raw_outputs/lstm_h:0' ]) self.session = tf.InteractiveSession(graph=self.graph) tf_scores = self.graph.get_tensor_by_name('import/detection_scores:0') tf_boxes = self.graph.get_tensor_by_name('import/detection_boxes:0') tf_classes = self.graph.get_tensor_by_name( 'import/detection_classes:0') tf_num_detections = self.graph.get_tensor_by_name( 'import/num_detections:0') tf_lstm_c = self.graph.get_tensor_by_name( 'import/raw_outputs/lstm_c:0') tf_lstm_h = self.graph.get_tensor_by_name( 'import/raw_outputs/lstm_h:0') self._output_nodes = [ tf_scores, tf_boxes, tf_classes, tf_num_detections, tf_lstm_c, tf_lstm_h ] self.lstm_c = np.ones((1, 8, 8, 320)) self.lstm_h = np.ones((1, 8, 8, 320))
def main(): args = parse_arguments() # Dataset dataset = Dataset(**vars(args)) # Reset the default graph and set a graph-level seed tf.reset_default_graph() tf.set_random_seed(9) # Model model = Model(num_classes=dataset.num_classes, **vars(args)) model.construct_model() # Session sess = tf.InteractiveSession() tf.global_variables_initializer().run() tf.local_variables_initializer().run() # Prune prune.prune(args, model, sess, dataset) # Train and test train.train(args, model, sess, dataset) test.test(args, model, sess, dataset) sess.close() sys.exit()
def __init__(self, num_actions): self.num_actions = num_actions self.epsilon = INITIAL_EPSILON self.epsilon_step = (INITIAL_EPSILON - FINAL_EPSILON) / EXPLORATION_STEPS self.t = 0 # Create replay memory self.replay_memory = deque() # Create q network self.s, self.q_values, q_network = self._build_network() q_network_weights = q_network.trainable_weights # Create target network self.st, self.target_q_values, target_network = self._build_network() target_network_weights = target_network.trainable_weights # Define target network update operation self.update_target_network = [ target_network_weights[i].assign(q_network_weights[i]) for i in range(len(target_network_weights)) ] # Define loss and gradient update operation self.a, self.y, self.loss, self.grads_update = self._build_training_op( q_network_weights) self.sess = tf.InteractiveSession() self.saver = tf.train.Saver(q_network_weights) self.sess.run(tf.global_variables_initializer()) # Initialize target network self.sess.run(self.update_target_network)
def set_up(): # variables which we need to fill in when we are ready to compute the graph. # We'll pass in the values of the x-axis to a placeholder called X. X = tf.placeholder(tf.float32, name='X') # And we'll also specify what the y values should be using another placeholder, y. Y = tf.placeholder(tf.float32, name='Y') sess = tf.InteractiveSession() n = tf.random_normal([1000], stddev=0.1).eval() # plt.hist(n) # We're going to multiply our input by 10 values, creating an "inner layer" # of n_neurons neurons. n_neurons = 10 # W = tf.Variable(tf.random_normal([1, n_neurons]), name='W') # # # # # and allow for n_neurons additions on each of those neurons # b = tf.Variable(tf.constant(0, dtype=tf.float32, shape=[n_neurons]), name='b') # # # Instead of just multiplying, we'll put our n_neuron multiplications through a non-linearity, the tanh function. # h = tf.nn.tanh(tf.matmul(tf.expand_dims(X, 1), W) + b, name='h') h = linear(tf.expand_dims(X, 1), 1, 10, scope='layer1', activation=tf.nn.tanh) h2 = linear(h, 10, 3, scope='layer2', activation=tf.nn.tanh) Y_pred = tf.reduce_sum(h2, 1) cost = tf.reduce_mean(distance(Y_pred, Y)) return X, Y, Y_pred, cost
def valid_nin(): print( bcolors.G + "Task : val\nvalidate the pre-trained nin model, should be same as caffe result" + bcolors.END) pool3 = nin() #pool3 = lenet() gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1.0) sess = tf.InteractiveSession(config=tf.ConfigProto( gpu_options=gpu_options)) init = tf.initialize_all_variables() sess.run(init) mean = cal_mean() data, label = read_cifar10('test') total = 0 correct = 0 begin = time.time() for j in range(len(data) // batch_size): batch_x = data[j * batch_size:(j + 1) * batch_size] - mean prob = sess.run([pool3], feed_dict={ x: batch_x, y: np.ones((batch_size)), keep_prob: 1.0 }) if np.argmax(prob[0]) == label[j]: correct += 1 total += 1 end = time.time() print("acc = %f . %d/%d. Computing time = %f seconds" % (float(correct) / total, correct, total, end - begin))
def __init__(self, state_size, window_size, trend, skip, batch_size): self.state_size = state_size self.window_size = window_size self.half_window = window_size // 2 self.trend = trend self.skip = skip self.action_size = 3 self.batch_size = batch_size self.memory = deque(maxlen=1000) self.inventory = [] self.gamma = 0.95 self.epsilon = 0.5 self.epsilon_min = 0.01 self.epsilon_decay = 0.999 tf.reset_default_graph() self.sess = tf.InteractiveSession() self.X = tf.placeholder(tf.float32, [None, self.state_size]) self.Y = tf.placeholder(tf.float32, [None, self.action_size]) feed = tf.layers.dense(self.X, 512, activation=tf.nn.relu) tensor_action, tensor_validation = tf.split(feed, 2, 1) feed_action = tf.layers.dense(tensor_action, self.action_size) feed_validation = tf.layers.dense(tensor_validation, 1) self.logits = feed_validation + \ tf.subtract(feed_action, tf.reduce_mean( feed_action, axis=1, keep_dims=True)) self.cost = tf.reduce_mean(tf.square(self.Y - self.logits)) self.optimizer = tf.train.GradientDescentOptimizer(1e-5).minimize( self.cost) self.sess.run(tf.global_variables_initializer())
def save_config(params_dict, logdir): print(f"Saving config to {logdir}") text = "{\n\n" total_params = len(params_dict) for count, key in enumerate(params_dict): config_value = str(params_dict[key]) if re.search('[a-zA-Z]', config_value): if config_value.lower() != 'true': if config_value.lower() != 'false': if config_value[0] != '[': # TODO: Making a manual exception for parsing epsilon right now since it's the only number in # scientific notation. Should fix this. if key != "epsilon": config_value = f'"{config_value}"' if count == total_params - 1: text += f'"{str(key)}"' + ' : ' + config_value + '\n\n' else: text += f'"{str(key)}"' + ' : ' + config_value + ',\n\n' text += '\n\n}' sess = tf.InteractiveSession() summary_op = tf.summary.text("run_config", tf.convert_to_tensor(text)) summary_writer = tf.summary.FileWriter(f"{logdir}/config", sess.graph) text = sess.run(summary_op) summary_writer.add_summary(text, 0) summary_writer.flush() summary_writer.close() tf.reset_default_graph() print('Done!')
def __init__(self, state_size, window_size, trend, skip): self.state_size = state_size self.window_size = window_size self.half_window = window_size // 2 self.trend = trend self.skip = skip self.X = tf.placeholder(tf.float32, (None, self.state_size)) self.REWARDS = tf.placeholder(tf.float32, (None)) self.ACTIONS = tf.placeholder(tf.int32, (None)) feed_forward = tf.layers.dense(self.X, self.LAYER_SIZE, activation=tf.nn.relu) self.logits = tf.layers.dense(feed_forward, self.OUTPUT_SIZE, activation=tf.nn.softmax) input_y = tf.one_hot(self.ACTIONS, self.OUTPUT_SIZE) loglike = tf.log((input_y * (input_y - self.logits) + (1 - input_y) * (input_y + self.logits)) + 1) rewards = tf.tile(tf.reshape(self.REWARDS, (-1, 1)), [1, self.OUTPUT_SIZE]) self.cost = -tf.reduce_mean(loglike * (rewards + 1)) self.optimizer = tf.train.AdamOptimizer( learning_rate=self.LEARNING_RATE).minimize(self.cost) self.sess = tf.InteractiveSession() self.sess.run(tf.global_variables_initializer())
def main(): sess = tf.InteractiveSession() inp, out = createGraph() trainGraph(inp, out, sess)
def make_prediction(img, MODEL_PATH): tf.enable_eager_execution() to_predict = preprocess(img) x_img = to_predict.shape[0] y_img = to_predict.shape[1] if len(to_predict.shape) == 3: z_img = to_predict.shape[2] else: z_img = 1 PIXEL_COUNT = x_img * y_img * z_img LABEL_COUNT = 1 to_predict_reshape = np.reshape(to_predict, (1, x_img * y_img * z_img)) g = tf.Graph() with g.as_default(): session = tf.InteractiveSession() model = build_model(PIXEL_COUNT, LABEL_COUNT) saver = tf.train.Saver() saver.restore(session, MODEL_PATH) predictions = model.output.eval( session=session, feed_dict={model.x_placeholder: to_predict_reshape}) session.close() box_image, x, y, width, height = plot_images( to_predict, (predictions + 1) * (64, 32, 64, 32)) plate = result(to_predict, x, y, height, width) return box_image, plate
def __init__(self, state_size, window_size, trend, skip): self.state_size = state_size self.window_size = window_size self.half_window = window_size // 2 self.trend = trend self.INITIAL_FEATURES = np.zeros((4, self.state_size)) self.skip = skip tf.reset_default_graph() self.actor = Actor('actor-original', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE) self.actor_target = Actor('actor-target', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE) self.critic = Critic('critic-original', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE, self.LEARNING_RATE) self.critic_target = Critic('critic-target', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE, self.LEARNING_RATE) self.grad_critic = tf.gradients(self.critic.logits, self.critic.Y) self.actor_critic_grad = tf.placeholder(tf.float32, [None, self.OUTPUT_SIZE]) weights_actor = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='actor') self.grad_actor = tf.gradients(self.actor.logits, weights_actor, -self.actor_critic_grad) grads = zip(self.grad_actor, weights_actor) self.optimizer = tf.train.AdamOptimizer( self.LEARNING_RATE).apply_gradients(grads) self.sess = tf.InteractiveSession() self.sess.run(tf.global_variables_initializer())
def __init__(self, state_size, window_size, trend, skip): self.state_size = state_size self.window_size = window_size self.half_window = window_size // 2 self.trend = trend self.skip = skip tf.reset_default_graph() self.X = tf.placeholder(tf.float32, (None, self.state_size)) self.Y = tf.placeholder(tf.float32, (None, self.state_size)) self.ACTION = tf.placeholder(tf.float32, (None)) self.REWARD = tf.placeholder(tf.float32, (None)) self.batch_size = tf.shape(self.ACTION)[0] with tf.variable_scope('curiosity_model'): action = tf.reshape(self.ACTION, (-1, 1)) state_action = tf.concat([self.X, action], axis=1) save_state = tf.identity(self.Y) feed = tf.layers.dense(state_action, 32, activation=tf.nn.relu) self.curiosity_logits = tf.layers.dense(feed, self.state_size) self.curiosity_cost = tf.reduce_sum( tf.square(save_state - self.curiosity_logits), axis=1) self.curiosity_optimizer = tf.train.RMSPropOptimizer(self.LEARNING_RATE)\ .minimize(tf.reduce_mean(self.curiosity_cost)) total_reward = tf.add(self.curiosity_cost, self.REWARD) with tf.variable_scope("q_model"): with tf.variable_scope("eval_net"): x_action = tf.layers.dense(self.X, 128, tf.nn.relu) self.logits = tf.layers.dense(x_action, self.OUTPUT_SIZE) with tf.variable_scope("target_net"): y_action = tf.layers.dense(self.Y, 128, tf.nn.relu) y_q = tf.layers.dense(y_action, self.OUTPUT_SIZE) q_target = total_reward + self.GAMMA * tf.reduce_max(y_q, axis=1) action = tf.cast(self.ACTION, tf.int32) action_indices = tf.stack( [tf.range(self.batch_size, dtype=tf.int32), action], axis=1) q = tf.gather_nd(params=self.logits, indices=action_indices) self.cost = tf.losses.mean_squared_error(labels=q_target, predictions=q) self.optimizer = tf.train.RMSPropOptimizer( self.LEARNING_RATE).minimize( self.cost, var_list=tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, "q_model/eval_net")) t_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='q_model/target_net') e_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='q_model/eval_net') self.target_replace_op = [ tf.assign(t, e) for t, e in zip(t_params, e_params) ] self.sess = tf.InteractiveSession() self.sess.run(tf.global_variables_initializer())
def main(): # create session sess = tf.InteractiveSession() # input layer and output layer by creating graph inp, out = createGraph() # train our graph on input and output with session variables trainGraph(inp, out, sess)
def optimise(self, lr, iterations, verbose): self.sess = tf.InteractiveSession() objective = self.objective ###I have only made for optimising simple likelihoods but KL divergence could also be used optimiser = tf.train.AdamOptimizer( learning_rate=lr).minimize(objective) self.sess.run(tf.global_variables_initializer()) progress = int(np.ceil(iterations / 10)) for i in tqdm(range(iterations), leave=False): _, loss = self.sess.run((optimiser, objective), feed_dict={}) if verbose and (i % progress) == 0: print(' opt iter {:5}: objective = {}'.format(i, loss)) print('Noise Variance:', self.sess.run(self.noise_var)) for i in range(len(self.hparams)): print(f'{self.hparamd[i]}:', self.sess.run(self.hparams[i]))
def trainer(model_params): """Train a sketch-rnn model.""" np.set_printoptions(precision=8, edgeitems=6, linewidth=200, suppress=True) tf.logging.info('sketch-rnn') tf.logging.info('Hyperparams:') tf.logging.info('Loading data files.') datasets = load_dataset(FLAGS.data_dir, model_params) train_set = datasets[0] valid_set = datasets[1] test_set = datasets[2] model_params = datasets[3] eval_model_params = datasets[4] reset_graph() model = sketch_rnn_model.Model(model_params) eval_model = sketch_rnn_model.Model(eval_model_params, reuse=True) sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) if FLAGS.resume_training: load_checkpoint(sess, FLAGS.log_root) # Write config file to json file. tf.gfile.MakeDirs(FLAGS.log_root) with tf.gfile.Open(os.path.join(FLAGS.log_root, 'model_config.json'), 'w') as f: json.dump(list(model_params.values()), f, indent=True) train(sess, model, eval_model, train_set, valid_set, test_set)
def __init__(self, env): #Make Session sess = tf.InteractiveSession() self.env = env self.lr = 1e-4 #self.critic_lr=0.001 self.gamma = 0.99 self.gae = 0.95 self.net = ACModel( env, 'net', ) self.old_net = ACModel(env, 'old') #PPO Parameters self.ppo_epochs = 10 self.batch_size = 64 self.clip_range = 0.2 #For entropy for exploration self.ent_coef = 0.01 self.saver = tf.train.Saver(max_to_keep=5000) self.build_update() self.build_update_models() self.utils = Utils() tf.get_default_session().run(tf.global_variables_initializer())