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')