def _init(self, emb_size, ac_space):
self.phi1 = tf.placeholder(dtype=tf.float32, shape=[None, emb_size], name='phi1')
self.phi2 = tf.placeholder(dtype=tf.float32, shape=[None, emb_size], name='phi2')
self.asample = asample = tf.placeholder(tf.float32, [None, ac_space.n])
# self.learning_rate = tf.placeholder(tf.float32, ())
size = 256
# forward model: f(phi1,asample) -> phi2
# Note: no backprop to asample of policy: it is treated as fixed for predictor training
f = tf.concat([self.phi1, asample], 1)
f1 = tf.nn.relu(linear(f, size, "f1", normalized_columns_initializer(0.01)))
f2 = linear(f1, self.phi1.get_shape()[1].value, "f2", normalized_columns_initializer(0.01))
self.forwardloss = 0.5 * tf.reduce_sum(tf.square(tf.subtract(f2, self.phi2)), name='forwardloss')
self.forwardloss = self.forwardloss / 288 # lenFeatures=288. Factored out to make hyperparams not depend on it.
# self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.forwardloss, var_list=self.get_trainable_variables())
var_list = self.get_trainable_variables()
self.lossandgrad = U.function([self.phi1, self.phi2, self.asample], [self.forwardloss] + [U.flatgrad(self.forwardloss, var_list)])
self.adam = MpiAdam(var_list, epsilon=1e-5)
U.initialize()
self.adam.sync()
def _init(self, ac_space, emb_size=None, emb_network=None):
self.emb_network = emb_network
self.s1, self.phi1 = self.emb_network.get_input_and_last_layer()
self.s2, self.phi2 = self.emb2.get_input_and_last_layer()
# self.phi1 = tf.placeholder(dtype=tf.float32, shape=[None, emb_size], name='phi1')
# self.phi2 = tf.placeholder(dtype=tf.float32, shape=[None, emb_size], name='phi2')
self.asample = asample = tf.placeholder(tf.float32, [None, ac_space.n])
size = 256
# inverse model: g(phi1,phi2) -> a_inv: [None, ac_space]
g = tf.concat([self.phi1, self.phi2], 1)
g = tf.nn.relu(linear(g, size, "g1", normalized_columns_initializer(0.01)))
aindex = tf.argmax(self.asample, axis=1) # aindex: [batch_size,]
logits = linear(g, ac_space.n, "glast", normalized_columns_initializer(0.01))
self.invloss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=logits, labels=aindex), name="invloss")
self.ainvprobs = tf.nn.softmax(logits, dim=-1)
var_list = self.get_trainable_variables()
self.lossandgrad = U.function([self.s1, self.s2, self.asample], [self.invloss] + [U.flatgrad(self.invloss, var_list)])
self.adam = MpiAdam(var_list, epsilon=1e-5)
U.initialize()
self.adam.sync()
def train_model():
if request.method == "POST":
if request.form["aim"] and request.form["means"]:
file_path = request.form.get("file_path")
aim = request.form["aim"]
df = pd.read_csv(file_path)
model = linear(df, aim)
def main(display=False, save=False):
# generate data
K = 3
data = generate(dim=2, classes=K, samples=100);
if display or save:
# initialize plots
plt.hold(True)
plt.close('all')
# display the raw data
plt.figure()
filename = "spiral_raw.pdf" if save else __
disp_data(data, ([-1,1], [-1,1]), display, filename)
# network models
hidden = 100 # size of hidden layer
std = .01 # weight initialization scale
linear = models.linear(std)
two_layer = models.two_layer(std, hidden)
# batch parameters
batch = 100 # mini-batch size
interval = lambda e: e / 10 # every how many epochs to report
seq = pn.split(batch)(data) # split data
# learning parameters
rate = 5e-1 # learning rate
decay = 1e-3 # weight decay parameter
data_loss = pn.logistic()
reg_loss = pn.l2_reg(decay)
solver = pn.sgd(rate)
# learn classifiers
for (model, name, epochs) in (
(linear, "linear", 50),
(two_layer, "two-layer", 1200),
):
print("\n%s classifier:" % name)
network = pn.supervise(model, data_loss, reg_loss)
classify, train = pn.learn(network, solver, dim=K)
loop(train(*seq), epochs, interval(epochs))
# dump network
print('\nnetwork dump:')
pn.net.dump()
# evaluate on training set
evaluate(data, classify)
# display classifier
filename = "spiral_%s.pdf" % name if save else __
if display or save: disp_class(data, classify, display, filename)
# finalize plots
if display or save: plt.hold(False)
def _init(self, ac_space, joint_training, emb_size=None, emb_network=None):
self.pdtype = pdtype = make_pdtype(ac_space)
self.emb_network = emb_network
self.joint_training = joint_training
size = 256
if self.joint_training:
self.input, output = emb_network.get_input_and_last_layer()
x = tf.nn.relu(linear(output, size, 'lin1', normalized_columns_initializer(1.0)))
else:
self.input = U.get_placeholder(name="ob", dtype=tf.float32, shape=[None, emb_size])
x = tf.nn.relu(linear(self.input, size, 'lin1', normalized_columns_initializer(1.0)))
# x = tf.nn.relu(linear(x, 32, 'lin2', normalized_columns_initializer(1.0)))
logits = linear(x, pdtype.param_shape()[0], "logits", normalized_columns_initializer(0.01))
self.pd = pdtype.pdfromflat(logits)
self.ac = self.pd.sample()
# self.probs = tf.nn.softmax(logits, dim=-1)[0, :]
self.vpred = linear(x, 1, "value", normalized_columns_initializer(1.0))
self._act = U.function([self.input], [self.ac, self.vpred])
def _init(self, ob_space, ac_space, embedding_space_size):
assert isinstance(ob_space, gym.spaces.Box)
# self.input = tf.placeholder(dtype=tf.float32, shape=[sequence_length] + list(ob_space.shape))
self.input = U.get_placeholder(name="ob_f",
dtype=tf.float32,
shape=[None] + list(ob_space.shape))
self.embedding_space = embedding_space_size
# x = self.input / 255.0
x = tf.nn.relu(
conv2d(self.input, 32, "cnn1", [8, 8], [4, 4], pad="VALID"))
x = tf.nn.relu(conv2d(x, 64, "cnn2", [4, 4], [2, 2], pad="VALID"))
x = tf.nn.relu(conv2d(x, 64, "cnn3", [3, 3], [1, 1], pad="VALID"))
x = flatten(x)
self.output = tf.nn.relu(
linear(x, self.embedding_space, 'linlast',
normalized_columns_initializer(1.0)))
import pylab as pl
import pymc as mc
import models
import graphics
# make model
vars = models.linear()
# fit model with MCMC
m = mc.MCMC(vars)
m.sample(iter=10000, burn=5000, thin=5)
# display results
pl.figure(figsize=(12, 9))
graphics.plot_2005_data()
graphics.plot_linear_model(m)
pl.savefig('../tex/ex1.png')
def test_linear_model(self):
vars = models.linear()
assert 'beta' in vars
import pylab as pl
import pymc as mc
import models
import graphics
# make model
vars = models.linear()
# fit model with MCMC
m = mc.MCMC(vars)
m.sample(iter=10000, burn=5000, thin=5)
# display results
pl.figure(figsize=(12,9))
graphics.plot_2005_data()
graphics.plot_linear_model(m)
pl.savefig('../tex/ex1.png')
