def test_variable(self):
# Bulk Tests
with tf.Graph().as_default():
W = tflearn.variable(name='W1', shape=[784, 256],
initializer='uniform_scaling',
regularizer='L2')
W = tflearn.variable(name='W2', shape=[784, 256],
initializer='uniform_scaling',
regularizer='L2')
def test_variable(self):
# Bulk Tests
with tf.Graph().as_default():
W = tflearn.variable(name='W1',
shape=[784, 256],
initializer='uniform_scaling',
regularizer='L2')
W = tflearn.variable(name='W2',
shape=[784, 256],
initializer='uniform_scaling',
regularizer='L2')
def __init__(self, hidden_dim=100, state_dim=128, batch_size=1):
"""
Instantiate an Addition Core object, with the necessary hyperparameters.
"""
self.hidden_dim, self.state_dim, self.bsz = hidden_dim, state_dim, batch_size
self.env_dim = CONFIG["ENVIRONMENT_ROW"] * CONFIG[
"ENVIRONMENT_DEPTH"] # 4 * 10 = 40
self.arg_dim = CONFIG["ARGUMENT_NUM"] * CONFIG[
"ARGUMENT_DEPTH"] # 3 * 10 = 30
self.program_dim = CONFIG["PROGRAM_EMBEDDING_SIZE"]
# Setup Environment Input Layer
self.env_in = tf.placeholder(tf.float32,
shape=[self.bsz, self.env_dim],
name="Env_Input")
# Setup Argument Input Layer
self.arg_in = tf.placeholder(tf.float32,
shape=[self.bsz, self.arg_dim],
name="Arg_Input")
# Setup Program ID Input Layer
self.prg_in = tf.placeholder(tf.int32,
shape=[None, 1],
name='Program_ID')
# Build Environment Encoder Network (f_enc)
self.state_encoding = self.build_encoder()
# Build Program Matrices
self.program_key = tflearn.variable(
name='Program_Keys',
shape=[CONFIG["PROGRAM_NUM"], CONFIG["PROGRAM_KEY_SIZE"]],
initializer='truncated_normal')
self.program_embedding = self.build_program_store()
def run():
# model variables
X = tf.placeholder('float', [None, 784])
Y = tf.placeholder('float', [None, 10])
W1 = tf.Variable(tf.random_normal([784, 256]))
W2 = tf.Variable(tf.random_normal([256, 256]))
W3 = tf.Variable(tf.random_normal([256, 10]))
b1 = tf.Variable(tf.random_normal([256]))
b2 = tf.Variable(tf.random_normal([256]))
b3 = tf.Variable(tf.random_normal([10]))
def dnn(x):
# using tflearn PReLU activation ops
x = tflearn.prelu(tf.add(tf.matmul(x, W1), b1))
tflearn.summaries.monitor_activation(x) # Monitor activation
x = tflearn.prelu(tf.add(tf.matmul(x, W2), b2))
tflearn.summaries.monitor_activation(x) # Monitor activation
x = tf.nn.softmax(tf.add(tf.matmul(x, W3), b3))
return x
net = dnn(X)
# use objective ops from TFLearn
loss = tflearn.categorical_crossentropy(net, Y)
# use metric ops from TFLearn
acc = tflearn.metrics.accuracy_op(net, Y)
# use SGF Optimizer class from TFLearn
optimizer = tflearn.SGD(learning_rate=0.1, lr_decay=0.96, decay_step=200)
# Because of lr decay, it is required to first build the Optimizer with
# the step tensor that will monitor training step.
# (Note: When using TFLearn estimators wrapper, build is self managed,
# so only using above `Optimizer` class as `DNN` optimizer arg is enough).
step = tflearn.variable('step', initializer='zeros', shape=[])
optimizer.build(step_tensor=step)
optim_tensor = optimizer.get_tensor()
# Use TFLearn Trainer
# def training op for backprop
trainop = tflearn.TrainOp(loss=loss, optimizer=optim_tensor,
metric=acc, batch_size=128,
step_tensor=step)
trainer = tflearn.Trainer(train_ops=trainop, tensorboard_verbose=3)
trainer.fit({X: trainX, Y: trainY}, val_feed_dicts={
X: testX, Y: testY}, n_epoch=2, show_metric=True)
def __init__(self, obs_dim, act_dim, gamma):
self.obs_dim = obs_dim
self.act_dim = act_dim
self.gamma = gamma
self.Q_max = 0
self.weights_path = 'models/qnet'
if not os.path.exists(self.weights_path):
os.makedirs(self.weights_path)
self.g = tf.Graph()
with self.g.as_default():
self.obs_ph = tf.placeholder(tf.float32, (None, self.obs_dim), 'obs')
self.act_ph = tf.placeholder(tf.float32, (None, self.act_dim), 'act')
self.y_ph = tf.placeholder(tf.float32, (None, 1), 'y')
# Make policy
self.Q = self._qnet(self.obs_ph, self.act_ph, reuse=False)
self.lr = 1e-3
self.tderr = tf.losses.mean_squared_error(self.Q, self.y_ph)
self.optim = tf.train.AdamOptimizer(self.lr).minimize(self.tderr)
# Optimization action
self.opt_act = tfl.variable("opt_act", shape=(act_dim))
self.Q_opt = self._qnet(self.obs_ph, tf.expand_dims(self.opt_act, 0), reuse=True)
self.init_act_rnd = tf.assign(self.opt_act, tf.random_normal(tf.shape(self.opt_act)))
self.init_act_zero = tf.assign(self.opt_act, tf.zeros(tf.shape(self.opt_act)))
self.optimize_action = tf.train.AdamOptimizer(5e-3).minimize(-self.Q_opt, var_list=self.opt_act)
self.init = tf.global_variables_initializer()
config = tf.ConfigProto(
device_count={'GPU': 0}
)
self.sess = tf.Session(graph=self.g, config=config)
self.sess.run(self.init)
net = dnn(X)
# Using objective ops from TFLearn to compute crossentropy
loss = tflearn.categorical_crossentropy(net, Y)
# Using metric ops from TFLearn to compute accuracy
acc = tflearn.metrics.accuracy_op(net, Y)
# Using TFLearn SGD Optimizer class
optimizer = tflearn.SGD(learning_rate=0.1, lr_decay=0.96, decay_step=200)
# Because of lr decay, it is required to first build the Optimizer with
# the step tensor that will monitor training step.
# (Note: When using TFLearn estimators wrapper, build is self managed,
# so only using above 'Optimizer' class as 'DNN' optimizer arg is enough).
step = tflearn.variable("step", initializer='zeros', shape=[])
optimizer.build(step_tensor=step)
optim_tensor = optimizer.get_tensor()
# Using TFLearn Trainer
# Define a training op (op for backprop, only need 1 in this model)
trainop = tflearn.TrainOp(loss=loss,
optimizer=optim_tensor,
metric=acc,
batch_size=128,
step_tensor=step)
# Create Trainer, providing all training ops. Tensorboard logs stored
# in /tmp/tflearn_logs/. It is possible to change verbose level for more
# details logs about gradients, varibles etc...
trainer = tflearn.Trainer(train_ops=trainop, tensorboard_verbose=0)
import tflearn from tflearn.models.dnn import DNN from tflearn.models.generator import SequenceGenerator from tflearn.data_utils import VocabularyProcessor from tflearn.data_preprocessing import DataPreprocessing from tflearn.helpers.trainer import Trainer from tflearn.helpers.evaluator import Evaluator from tflearn.helpers.summarizer import summarize from tflearn.helpers.regularizer import add_weights_regularizer from tensorflow.contrib.slim import dataset from tensorflow.contrib.slim import dataset tflearn.input_data() tflearn.variable() tflearn.conv_2d() tflearn.single_unit() tflearn.lstm() tflearn.embedding() tflearn.batch_normalization() tflearn.merge() tflearn.regression() tflearn.tanh() tflearn.softmax_categorical_crossentropy() tflearn.SGD() tflearn.initializations.uniform() tflearn.losses.L1() tflearn.add_weights_regularizer() tflearn.metrics.Accuracy() tflearn.summaries() tflearn.ImagePreprocessing() tflearn.ImageAugmentation()
return x
net = dnn(X)
# Using objective ops from TFLearn to compute crossentropy
loss = tflearn.categorical_crossentropy(net, Y)
# Using metric ops from TFLearn to compute accuracy
acc = tflearn.metrics.accuracy_op(net, Y)
# Using TFLearn SGD Optimizer class
optimizer = tflearn.SGD(learning_rate=0.1, lr_decay=0.96, decay_step=200)
# Because of lr decay, it is required to first build the Optimizer with
# the step tensor that will monitor training step.
# (Note: When using TFLearn estimators wrapper, build is self managed,
# so only using above `Optimizer` class as `DNN` optimizer arg is enough).
step = tflearn.variable("step", initializer="zeros", shape=[])
optimizer.build(step_tensor=step)
optim_tensor = optimizer.get_tensor()
# Using TFLearn Trainer
# Define a training op (op for backprop, only need 1 in this model)
trainop = tflearn.TrainOp(loss=loss, optimizer=optim_tensor, metric=acc, batch_size=128, step_tensor=step)
# Create Trainer, providing all training ops. Tensorboard logs stored
# in /tmp/tflearn_logs/. It is possible to change verbose level for more
# details logs about gradients, variables etc...
trainer = tflearn.Trainer(train_ops=trainop, tensorboard_verbose=0)
# Training for 10 epochs.
trainer.fit({X: trainX, Y: trainY}, val_feed_dicts={X: testX, Y: testY}, n_epoch=10, show_metric=True)
x = tf.nn.softmax(tf.add(tf.matmul(x, W3), b3))
return x
net = dnn(X)
loss = tflearn.categorical_crossentropy(net, Y)
acc = tflearn.metrics.accuracy_op(net, Y)
optimizer = tflearn.SGD(learning_rate=0.1, lr_decay=0.96, decay_step=200)
# Because of lr decay, it is required to first build the Optimizer with
# the step tensor that will monitor training step.
# (Note: When using TFLearn estimators wrapper, build is self managed,
# so only using above `Optimizer` class as `DNN` optimizer arg is enough).
step = tflearn.variable('step', initializer='zeros', shape=[])
optimizer.build(step_tensor=step)
optim_tensor = optimizer.get_tensor()
# Using TFLearn Trainer
# Define a training op (op for backprop, only need 1 in this model)
trainop = tflearn.TrainOp(loss=loss,
optimizer=optim_tensor,
metric=acc,
batch_size=128,
step_tensor=step)
# Create Trainer, providing all training ops. Tensorboard logs stored
# in /tmp/tflearn_logs/. It is possible to change verbose level for more
# details logs about gradients, variables etc...