def build_gan_trainer():
target = None
# Place Holder
input_x = tflearn.input_data(shape=(None, X_SIZE), name="input_x")
input_z = tflearn.input_data(shape=(None, Z_SIZE), name="input_z")
# Generator
G_sample = build_generator(input_z, scope=G_SCOPE)
target = G_sample
# Discriminator
D_origin = build_discriminator(input_x, scope=D_SCOPE)
D_fake = build_discriminator(G_sample, scope=D_SCOPE, reuse=True)
# Loss
D_loss = -tf.reduce_mean(tf.log(D_origin) + tf.log(1. - D_fake))
G_loss = -tf.reduce_mean(tf.log(D_fake))
# Optimizer
G_opt = tflearn.Adam(learning_rate=0.001).get_tensor()
D_opt = tflearn.Adam(learning_rate=0.001).get_tensor()
# Vars
G_vars = get_trainable_variables(G_SCOPE)
D_vars = get_trainable_variables(D_SCOPE)
# TrainOp
G_train_op = tflearn.TrainOp(loss=G_loss,
optimizer=G_opt,
batch_size=BATCH_SIZE,
trainable_vars=G_vars,
name="Generator")
D_train_op = tflearn.TrainOp(loss=D_loss,
optimizer=D_opt,
batch_size=BATCH_SIZE,
trainable_vars=D_vars,
name="Discriminator")
# Trainer
gan_trainer = tflearn.Trainer(
[D_train_op, G_train_op],
tensorboard_dir=TENSORBOARD_DIR,
# checkpoint_path=CHECKPOINT_DIR, # エラー
max_checkpoints=1)
return gan_trainer, target
def build_network(p, input_num):
network = tflearn.input_data(shape=[None, input_num])
for layer in p.layers:
network = tflearn.fully_connected(network,
layer[1],
activation=layer[2],
weights_init=p.weights_init)
if p.batch_norm:
network = tflearn.batch_normalization(network)
if layer[3] < 1.0:
network = tflearn.dropout(network, layer[3])
network = tflearn.fully_connected(network,
p.class_num,
activation="softmax")
if p.optimizer == "sgd":
optimizer = tflearn.SGD(learning_rate=p.learning_rate,
lr_decay=p.lr_decay,
decay_step=p.decay_step)
elif p.optimizer == "momentum":
optimizer = tflearn.Momentum(learning_rate=p.learning_rate,
lr_decay=p.lr_decay,
decay_step=p.decay_step)
elif p.optimizer == "adagrad":
optimizer = tflearn.AdaGrad(learning_rate=p.learning_rate)
else:
optimizer = tflearn.Adam(learning_rate=p.learning_rate)
network = tflearn.regression(network,
optimizer=optimizer,
loss="categorical_crossentropy")
return network
def __call__(self,
#opt_learning_rate=0.001,
#opt_epsilon=1e-8,
**kwargs):
return tflearn.Adam(
learning_rate=(kwargs['opt_learning_rate'] if 'opt_learning_rate' in kwargs else 0.001),
epsilon=(kwargs['opt_epsilon'] if 'opt_epsilon' in kwargs else 1e-8))
def run_moel():
softmax = build_neural_network()
optimizer = tflearn.Adam(0.001)
net = tflearn.regression(softmax, optimizer = optimizer, metric = tflearn.metrics.Accuracy(),
loss = 'categorical_crossentropy')
model = tflearn.DNN(net)
model.fit(x_train, y_train, n_epoch = 10, batch_size = 100, show_metric = True)
result = model.evaluate(x_test, y_test)
print ("lost: ", "accuracy: ", result)
kinase_dropout = tf.mul(kinase, kinase_deletion)
transcription_factor = tflearn.fully_connected(kinase_dropout, num_transcription_factors, activation='relu', name='Transcription_Factor')
with tf.name_scope('TF_Targets'):
W = tf.Variable(tf.random_uniform([num_transcription_factors, num_genes]), name='Weights')
b = tf.Variable(tf.zeros([num_genes]), name='biases')
#gene = tf.matmul( tf.mul(tf_connectivity, W), transcription_factor) + b
transcription_factor_targets = tf.mul(tf_connectivity, W)
with tf.name_scope('Gene'):
gene = tf.matmul(transcription_factor, transcription_factor_targets) + b
#gene = tflearn.fully_connected(transcription_factor, num_genes, activation='linear')
adam = tflearn.Adam(learning_rate=0.00001, beta1=0.99)
regression = tflearn.regression(gene, optimizer=adam, loss='mean_square', metric='R2')
# Define model
model = tflearn.DNN(regression, tensorboard_verbose=1)
# In[ ]:
# Start training (apply gradient descent algorithm)
#model.fit([data1, data2], target, n_epoch=200, show_metric=True, shuffle=True, validation_set=0.10)
model.fit([data1, data2], target, n_epoch=200, show_metric=True, shuffle=True, batch_size=20, validation_set=0.10)
model.save('mymodel_relu_cocktail_with_val_and_dropout_and_reg_test.tflearn')
input_layer = tflearn.input_data(shape=[None, vector_size])
dense1 = tflearn.fully_connected(input_layer, 64, activation='tanh',
regularizer='L2', weight_decay=0.001)
dropout1 = tflearn.dropout(dense1, drop_pro)
dense2 = tflearn.fully_connected(dropout1, 128, activation='tanh',
regularizer='L2', weight_decay=0.001)
dropout2 = tflearn.dropout(dense2, drop_pro)
dense3 = tflearn.fully_connected(dropout1, 64, activation='tanh',
regularizer='L2', weight_decay=0.001)
dropout3 = tflearn.dropout(dense2, drop_pro)
softmax = tflearn.fully_connected(dropout3, lab_size, activation='softmax')
# Regression using SGD with learning rate decay and Top-3 accuracy
sgd = tflearn.SGD(learning_rate=0.01, lr_decay=0.96, decay_step=1000)
adam = tflearn.Adam(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name="Adam")
# loss = tflearn.losses.L2()
# top_k = tflearn.metrics.Top_k(6)
accu = tflearn.metrics.Accuracy()
net = tflearn.regression(softmax, optimizer=adam, metric=accu)
# optimizer = tflearn.optimizers.Optimizer(learning_rate=0.01, False, "")
# loss = tf.reduce_mean(tf.nn.log_poisson_loss(logits=softmax, labels=Y))
# optimizer = tf.train.AdamOptimizer(learning_rate=0.01).minimize(loss)
# init = tf.global_variables_initializer()
dnn = DNN(net, clip_gradients=5.0, tensorboard_verbose=0,
tensorboard_dir='/tmp/tflearn_logs/', checkpoint_path=None,
best_checkpoint_path=None, max_checkpoints=None,
session=None, best_val_accuracy=0.0)
# import csv
# df_test[['citizen_id', 'Voted_to_ref']] \
# .to_csv('snark _IITKharagpur_1.csv', index = False, quoting=csv.QUOTE_NONNUMERIC, header = False)
############ Method 2
import tflearn
net = tflearn.input_data(shape=[None, 34])
net = tflearn.fully_connected(net, 68)
net = tflearn.fully_connected(net, 68, activation='sigmoid')
net = tflearn.fully_connected(net, 68)
net = tflearn.fully_connected(net, 68, activation='sigmoid')
net = tflearn.fully_connected(net, 68)
net = tflearn.fully_connected(net, 68, activation='sigmoid')
net = tflearn.fully_connected(net, 34)
net = tflearn.fully_connected(net, 5, activation='softmax')
adam = tflearn.Adam(learning_rate=0.0001)
net = tflearn.regression(net,
optimizer='adam',
loss='categorical_crossentropy')
model = tflearn.DNN(net)
labels = np.zeros((len(y), 5))
for i in range(len(y)):
labels[i][y[i]] = 1
model.fit(X, labels, n_epoch=1000, batch_size=16, show_metric=True)
df_test = pd.read_csv('Leaderboard_Dataset.csv')
df_test = clean_data(df_test, False)
test_data = df_test.values
test_x = test_data[:, 1:]
train_set = np.concatenate((train_pos_set, train_neg_set), axis=0)
test_set = np.concatenate((test_pos_set, test_neg_set), axis=0)
X_train = train_set[:, :-1]
Y_train = to_categorical(train_set[:, -1:].flatten(), 2)
X_test = test_set[:, :-1]
Y_test = to_categorical(test_set[:, -1:].flatten(), 2)
# train a linear classifier
with tf.Graph().as_default():
prep = data_prep.DataPreprocessing()
prep.add_featurewise_zero_center()
prep.add_featurewise_stdnorm()
net = tflearn.input_data([None, d])
net = tflearn.fully_connected(net, 150, activation='relu')
net = tflearn.fully_connected(net, 2, activation='softmax')
gd = tflearn.Adam(learning_rate=0.01)
net = tflearn.regression(net,
optimizer=gd,
loss='categorical_crossentropy')
model = tflearn.DNN(net, tensorboard_verbose=0)
model.fit(X_train, Y_train, n_epoch=500, show_metric=True)
print(np.argmax(model.predict(X_test), axis=1))
print("Accuracy: {}%".format(100 * np.mean(
test_set[:, -1:].flatten() == np.argmax(model.predict(X_test), axis=1))))
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('envname', type=str)
parser.add_argument('expert_policy_file', type=str)
parser.add_argument("data", type=str)
parser.add_argument("--model", type=str, default='None')
parser.add_argument("--epochs", type=int, default=5)
parser.add_argument("--output", type=str, default='None')
parser.add_argument("--percent", type=int, default=100)
args = parser.parse_args()
import gym
env = gym.make(args.envname)
import tflearn
print('loading data')
with open(args.data, 'rb') as f:
obs, act = pickle.load(f)
print(' -> done!')
if (args.percent < 100):
n = int(args.percent / 100.0 * obs.shape[0])
obs = obs[:n, :]
act = act[:n, :]
batch_size = 256
#### Build Model
X = obs
Y = act.squeeze()
input_size = X.shape[1]
hid1 = 32
hid2 = 16
output_size = Y.shape[1]
input_layer = tflearn.input_data(shape=[None, input_size])
layer1 = tflearn.fully_connected(input_layer,
hid1,
activation='relu',
regularizer='L2',
weight_decay=0.001)
layer2 = tflearn.fully_connected(layer1,
hid2,
activation='relu',
regularizer='L2',
weight_decay=0.001)
output_layer = tflearn.fully_connected(layer2,
output_size,
activation='linear')
adam = tflearn.Adam(learning_rate=0.001)
net = tflearn.regression(output_layer, optimizer=adam, loss='mean_square')
model = tflearn.DNN(net)
if args.model is 'None':
model.fit(X,
Y,
batch_size=256,
n_epoch=args.epochs,
shuffle=True,
show_metric=True,
run_id='behavior clone: ' + args.envname)
model.save('model/' + args.envname + '.tfl')
else:
model.load(args.model)
#return
# evaluate
print('loading and building expert policy')
policy_fn = load_policy.load_policy(args.expert_policy_file)
print('loaded and built')
eval_num = 50
max_steps = 500
targets = []
with tf.Session():
tf_util.initialize()
returns = []
for i in range(eval_num):
print('iter', i)
obs = env.reset()
done = False
totalr = 0.
steps = 0
while not done:
action = model.predict(obs[None, :])
obs, r, done, _ = env.step(action)
totalr += r
steps += 1
if steps % 100 == 0: print("%i/%i" % (steps, max_steps))
if steps >= max_steps:
break
returns.append(totalr)
# simulate target performance
obs = env.reset()
done = False
totalr = 0.
steps = 0
while not done:
action = policy_fn(obs[None, :])
obs, r, done, _ = env.step(action)
totalr += r
steps += 1
if steps % 100 == 0: print("%i/%i" % (steps, max_steps))
if steps >= max_steps:
break
targets.append(totalr)
filename = args.envname + '_result.pkl' if args.output is 'None' else args.output
print('returns', returns)
print('mean return', np.mean(returns))
print('std of return', np.std(returns))
with open(filename, 'wb') as f:
pickle.dump([returns, targets], f)
bias=False,
weights_init="truncated_normal",
bias_init="zeros",
trainable=True,
restore=True,
reuse=False,
scope=None,
name="FullyConnectedLayer_relu")
v_net = tflearn.fully_connected(v_net,
3,
activation="softmax",
name="OutputLayer")
v_net = tflearn.regression(v_net,
optimizer=tflearn.Adam(learning_rate=0.01,
epsilon=0.01),
metric=tflearn.metrics.accuracy(),
loss="categorical_crossentropy")
#define model
model = tflearn.DNN(v_net)
#load saved weights
model.load('C:/temp/Tensorflow/v01/relu_adam_001.tf_model')
#prediction
prediction = model.predict(df_data[df_data.columns[1:5]])
#add predictions to data frame
df_data['PROB_HOME_WIN'] = prediction[:, 0]
df_data['PROB_DRAW'] = prediction[:, 1]
weights_init='xavier',
activation="softsign",
name='First_Fully_Connected')
net = tflearn.highway(net, 32, activation="softsign", name="highwayLayer")
net = tflearn.fully_connected(net,
32,
weights_init='xavier',
activation="softsign",
name='Third_Fully_Connected')
net = tflearn.fully_connected(net,
5,
activation="softmax",
name='Final_Fully_Connected')
# todo: confusion matrix
adam = tflearn.Adam()
net = tflearn.regression(net, learning_rate=0.001, optimizer=adam)
# Define model
model = tflearn.DNN(net,
clip_gradients=1.0,
tensorboard_verbose=3,
tensorboard_dir='./tmp/weather.log')
# Start training (apply gradient descent algorithm)
model.fit(TrainingSetFeatures,
TrainingSetLabels,
n_epoch=15,
batch_size=24,
show_metric=True)
def my_model(X, y):
y = tf.one_hot(y, 10)
network = tflearn.conv_2d(X,
nb_filter=32,
filter_size=3,
strides=1,
activation="linear",
padding="valid",
name="conv1",
weight_decay=0.01)
network = tflearn.batch_normalization(network, name="bn1")
network = tflearn.relu(network)
network = tflearn.max_pool_2d(network,
kernel_size=2,
strides=2,
padding="same",
name="pool1")
network = tflearn.conv_2d(network,
nb_filter=64,
filter_size=3,
strides=1,
activation="linear",
padding="valid",
name="conv2",
weight_decay=0.01)
network = tflearn.batch_normalization(network, name="bn2")
network = tflearn.relu(network)
network = tflearn.max_pool_2d(network,
kernel_size=2,
strides=2,
padding="same",
name="pool2")
network = tflearn.flatten(network, name="flat1")
network = tflearn.fully_connected(network,
1024,
activation="linear",
name="fc1",
weight_decay=0.01)
network = tflearn.batch_normalization(network, name="bn2")
network = tflearn.relu(network)
network = tflearn.fully_connected(network,
1024,
activation="linear",
name="fc2",
weight_decay=0.01)
network = tflearn.batch_normalization(network, name="bn3")
network = tflearn.relu(network)
logits = tflearn.fully_connected(network,
10,
activation="softmax",
name="output",
weight_decay=0.01)
loss = tflearn.categorical_crossentropy(logits, y)
train_op = tflearn.Adam(0.0001, 0.9)().minimize(loss)
return logits, loss, train_op
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('envname', type=str)
parser.add_argument('expert_policy_file', type=str)
parser.add_argument("data", type=str)
parser.add_argument("--model", type=str, default='None')
parser.add_argument("--epochs", type=int, default=5)
parser.add_argument("--dagger_step", type=int, default=5)
parser.add_argument("--dagger_rollout", type=int, default=100)
args = parser.parse_args()
import gym
env = gym.make(args.envname)
import tflearn
print('loading data')
with open(args.data, 'rb') as f:
obs, act = pickle.load(f)
print(' -> done!')
batch_size = 256
#### Build Model
X = obs
Y = act.squeeze()
input_size = X.shape[1]
hid1 = 32
hid2 = 16
output_size = Y.shape[1]
input_layer = tflearn.input_data(shape=[None, input_size])
layer1 = tflearn.fully_connected(input_layer,
hid1,
activation='relu',
regularizer='L2',
weight_decay=0.001)
layer2 = tflearn.fully_connected(layer1,
hid2,
activation='relu',
regularizer='L2',
weight_decay=0.001)
output_layer = tflearn.fully_connected(layer2,
output_size,
activation='linear')
adam = tflearn.Adam(learning_rate=0.001)
net = tflearn.regression(output_layer, optimizer=adam, loss='mean_square')
model = tflearn.DNN(net)
if args.model is 'None':
model.fit(X,
Y,
batch_size=256,
n_epoch=args.epochs,
shuffle=True,
show_metric=True,
run_id='behavior clone: ' + args.envname)
model.save('model/' + args.envname + '.tfl')
else:
model.load(args.model)
#return
# evaluate
print('loading and building expert policy')
policy_fn = load_policy.load_policy(args.expert_policy_file)
print('loaded and built')
cur = evaluate(env, model)
ret_avg = [np.mean(cur)]
ret_std = [np.std(cur)]
ret_all = [cur]
for step in range(args.dagger_step):
print('dagger step #', step)
observations = []
actions = []
with tf.Session():
tf_util.initialize()
for i in range(args.dagger_rollout):
if i % 20 == 0:
print('rollout iter = ', i)
obs = env.reset()
done = False
totalr = 0.
steps = 0
while not done:
action = model.predict(obs[None, :])
obs, r, done, _ = env.step(action)
observations.append(obs)
actions.append(policy_fn(obs[None, :]))
totalr += r
steps += 1
if steps >= max_steps:
break
X = np.row_stack((X, np.array(observations)))
Y = np.row_stack((Y, np.array(actions).squeeze()))
model.fit(X,
Y,
batch_size=256,
n_epoch=args.epochs,
shuffle=True,
show_metric=True,
run_id='behavior clone: ' + args.envname)
model.save('model/' + args.envname + '-iter{a}.tfl'.format(a=step))
returns = evaluate(env, model)
ret_avg.append(np.mean(returns))
ret_std.append(np.std(returns))
ret_all.append(returns)
print('current avg return = {a}, std = {b}'.format(a=ret_avg[-1],
b=ret_std[-1]))
print('mean return', ret_avg)
print('std of return', ret_std)
with open(args.envname + '_dagger_result.pkl', 'wb') as f:
pickle.dump([ret_avg, ret_std, ret_all], f)
