def __init__(self, settings): # print "building controller ... " self.seq_info = tensor.tensor3(dtype=dtype, name='seq_info') self.seq_lang = tensor.tensor3(dtype=dtype, name='seq_lang') self.seq_target = tensor.tensor3(dtype=dtype, name='seq_target') # self.model = models.SelGen(settings) # self.model.compute_loss(self.seq_info, self.seq_lang, self.seq_target) # assert (settings['optimizer'] == 'adam' or settings['optimizer'] == 'sgd') if settings['optimizer'] == 'adam': self.adam_optimizer = optimizers.Adam(adam_params=None) elif settings['optimizer'] == 'sgd': self.adam_optimizer = optimizers.SGD(adam_params=None) else: print "Choose a optimizer ! " # self.adam_optimizer.compute_updates(self.model.params, self.model.grad_params) # print "compiling training function ... " self.model_learn = theano.function( inputs=[self.seq_info, self.seq_lang, self.seq_target], outputs=self.model.cost, updates=self.adam_optimizer.updates) print "compiling dev function ... " self.model_dev = theano.function( inputs=[self.seq_info, self.seq_lang, self.seq_target], outputs=self.model.cost) self.save_model = self.model.save_model self.get_model = self.model.get_model
def checkpoint0(dataset): data_dimension = dataset.get_data_dim() model = iwae.random_iwae(latent_units=[data_dimension] + latent_units, hidden_units_q=hidden_units_q, hidden_units_p=hidden_units_p, dataset=dataset ) srng = utils.srng() optimizer = optimizers.Adam(model=model, learning_rate=1e-3) return model, optimizer, srng
def __init__(self, model_settings): print "building trainer ... " self.seq_lang = tensor.ivector(name='seq_lang') self.seq_world = tensor.matrix( name='seq_world', dtype=dtype ) # shape -- len_path * dim_raw_world_input self.seq_action = tensor.ivector(name='seq_action') # self.model_settings = model_settings # self.neural_walker = models.NeuralWalker( model_settings = self.model_settings ) self.neural_walker.compute_loss( self.seq_lang, self.seq_world, self.seq_action ) # # assert( self.model_settings['optimizer'] == 'adam' or self.model_settings['optimizer'] == 'sgd' ) if self.model_settings['optimizer'] == 'adam': self.optimizer = optimizers.Adam() else: self.optimizer = optimizers.SGD() # self.optimizer.compute_updates( self.neural_walker.params, self.neural_walker.grad_params ) # self.model_learn = theano.function( inputs = [ self.seq_lang, self.seq_world, self.seq_action ], outputs = self.neural_walker.cost, updates = self.optimizer.updates ) # self.model_dev = theano.function( inputs = [ self.seq_lang, self.seq_world, self.seq_action ], outputs = self.neural_walker.cost, ) # self.get_model = self.neural_walker.get_model self.save_model = self.neural_walker.save_model
def run_classification(): model = Model.Model() model.add_layer(layers.Input(784)) model.add_layer(layers.Dense(100, activation=af.relu)) model.add_layer(layers.Dense(10, activation=af.softmax)) model.compile(losses.crossentropy, optimizers.Adam()) with gzip.open('data/mnist.pkl.gz', 'rb') as f: train_set, validation_set, test_set = pickle.load(f, encoding='latin1') n_train = train_set[0].shape[0] n_test = test_set[0].shape[0] train_set_onehots = helpers.make_onehot_2d(train_set[1], 10) test_set_onehots = helpers.make_onehot_2d(test_set[1], 10) model.fit(train_set[0], train_set_onehots, 50, 50, metric_dataset_x=test_set[0], metric_dataset_y=test_set_onehots, metric_callback=classification_metric_accuracy)
import layers import optimizers as op import neuralnet as NN from mnist import MNIST from pylab import cm mndata = MNIST("../") input_size = 784 mid_size = 100 out_size = 10 epoch = 1500 batch_size = 100 learning_rate = 0.01 sigmoid = False optimizers = [op.Adam(784, mid_size, 10)] print("loading...") print("load training data...") X, Y = mndata.load_training() print("load testing data...") X_test, Y_test = mndata.load_testing() print("> ", end="") i = int(input()) X = np.array(X) Y = np.array(Y) X_test = np.array(X_test) Y_test = np.array(Y_test) Xshow = X_test.reshape((X_test.shape[0], 28, 28)) plt.imshow(Xshow[i], cmap=cm.gray)
from quantum_diffs import ParameterShift def f(x): model.set_weights(np.array([x])) ret = model(train) return tf.keras.losses.MAE(train_label, tf.squeeze(ret)).numpy() def f1(x): model.set_weights(np.array([x])) ret = model(train) return ret.numpy() opt = optimizers.Adam(lr=0.01) cutsom = [] accs = [] i = 0 while i < N: guess = f(params) cutsom.append(guess) gradients = ParameterShift(f, params) params = opt.apply_grad(gradients, params) acc = np_hinge(train_label, f1(params).flatten()) accs.append(acc) if i % 10 == 0: print("Epoch {}/{}, Loss {}, Acc {}".format(i, N, guess, acc)) i += 1 plt.plot(tf_loss, label='TFQ')
def __init__( self, lossfunc, optimizer, batch_size=32, ): self.lossfunc = lossfunc self.optimizer = optimizer self.batch_size = batch_size input_size = 64 hidden_size = 3136 output_size = 10 # self.lr = 0.001 # self.alpha = 0.9 self.l1 = 1e-4 self.l2 = 1e-4 self.optimizer = optimizers.Adam(l1=self.l1, l2=self.l2) self.conv0 = L.Convolution_(n_filter=8, filter_size=(3, 3), stride=1) self.conv1 = L.Convolution_(n_filter=16, filter_size=(3, 3), stride=1) self.conv2 = L.Convolution_(n_filter=32, filter_size=(5, 5), stride=1) self.conv3 = L.Convolution_(n_filter=64, filter_size=(5, 5), stride=1) self.fc0 = L.Linear_(output_size=1024) self.fc1 = L.Linear_(output_size=10) self.bn0 = L.BatchNormalization_() self.bn1 = L.BatchNormalization_() self.bn2 = L.BatchNormalization_() self.bn3 = L.BatchNormalization_() self.bn4 = L.BatchNormalization_() self.acti0 = L.ELU() self.acti1 = L.ELU() self.acti2 = L.ELU() self.acti3 = L.ELU() self.acti4 = L.ELU() self.pool0 = L.MaxPooling(7, 7) self.pool1 = L.MaxPooling(5, 5) self.pool2 = L.MaxPooling(3, 3) self.pool3 = L.MaxPooling(3, 3) self.flat = L.Flatten() self.drop0 = L.Dropout(0.5) self.drop1 = L.Dropout(0.5) self.drop2 = L.Dropout(0.5) self.drop3 = L.Dropout(0.25) self.layers = [ self.conv0, self.acti0, self.pool0, self.bn0, #self.drop0, self.conv1, self.acti1, self.pool1, self.bn1, #self.drop1, #self.conv2, #self.acti2, #self.pool2, #self.bn2, #self.drop2, #self.conv3, #self.acti3, #self.pool3, #self.bn3, #self.drop3, self.flat, self.fc0, self.acti4, self.bn4, self.fc1, ]
def __init__(self, settings): print("building controller ... ") ''' seq_time_to_end : T * size_batch -- T - t_i seq_time_to_current : T * T * size_batch -- for each batch, it is T * T, and at each time step t, it tracks the ( t_i - t_i' ) for all t_i' < t_i seq_type_event : T * size_batch -- for each data and each time step, tracks the type of event k_i time_since_start_to_end : size_batch -- time for seq # seq_mask : T * size_batch -- 1/0 seq_mask_to_current : T * T * size_batch -- 1/0 ''' self.seq_time_to_end = tensor.matrix(dtype=dtype, name='seq_time_to_end') self.seq_time_to_current = tensor.tensor3(dtype=dtype, name='seq_time_to_current') self.seq_type_event = tensor.imatrix(name='seq_type_event') self.time_since_start_to_end = tensor.vector( dtype=dtype, name='time_since_start_to_end') self.seq_mask = tensor.matrix(dtype=dtype, name='seq_mask') self.seq_mask_to_current = tensor.tensor3(dtype=dtype, name='seq_mask_to_current') # self.seq_sims_time_to_current = tensor.tensor3( dtype=dtype, name='seq_sims_time_to_current') self.seq_sims_mask = tensor.matrix(dtype=dtype, name='seq_sims_mask') self.seq_sims_mask_to_current = tensor.tensor3( dtype=dtype, name='seq_sims_mask_to_current') # # self.hawkes_ctsm = models.HawkesCTSM(settings) # self.hawkes_ctsm.compute_loss(self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, self.time_since_start_to_end, self.seq_mask, self.seq_mask_to_current) # assert (settings['optimizer'] == 'adam' or settings['optimizer'] == 'sgd') if settings['optimizer'] == 'adam': self.adam_optimizer = optimizers.Adam(adam_params=None) elif settings['optimizer'] == 'sgd': self.adam_optimizer = optimizers.SGD(adam_params=None) else: print("Choose a optimizer ! ") # if 'learn_rate' in settings: print("learn rate is set to : ", settings['learn_rate']) self.adam_optimizer.set_learn_rate(settings['learn_rate']) # self.adam_optimizer.compute_updates(self.hawkes_ctsm.params, self.hawkes_ctsm.grad_params, list_constrain=range(3)) # print("compiling training function ... ") self.model_learn = theano.function( inputs=[ self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, self.time_since_start_to_end, self.seq_mask, self.seq_mask_to_current ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ], updates=self.adam_optimizer.updates) print("compiling dev function ... ") self.model_dev = theano.function( inputs=[ self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, self.time_since_start_to_end, self.seq_mask, self.seq_mask_to_current ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ]) if settings['predict_lambda']: print("compiling dev function for intensity computation ... ") self.hawkes_ctsm.compute_lambda(self.seq_type_event, self.seq_sims_time_to_current, self.seq_sims_mask, self.seq_sims_mask_to_current) self.model_dev_lambda = theano.function( inputs=[ self.seq_type_event, self.seq_sims_time_to_current, self.seq_sims_mask, self.seq_sims_mask_to_current ], outputs=[ self.hawkes_ctsm.lambda_samples, self.hawkes_ctsm.num_of_samples ]) # #self.get_model = self.hawkes_ctsm.get_model self.save_model = self.hawkes_ctsm.save_model
def __init__(self, settings): print("building controller ... ") ''' seq_time_to_end : T * size_batch -- T - t_i seq_time_to_current : T * T * size_batch -- for each batch, it is T * T, and at each time step t, it tracks the ( t_i - t_i' ) for all t_i' < t_i seq_type_event : T * size_batch -- for each data and each time step, tracks the type of event k_i time_since_start_to_end : size_batch -- time for seq num_sims_start_to_end : size_batch -- # of samples for seq # seq_mask : T * size_batch -- 1/0 seq_mask_to_current : T * T * size_batch -- 1/0 seq_sims_time_to_current : N * T * size_batch seq_sims_mask_to_current : N * T * size_batch seq_sims_mask : N * size_batch ''' #self.seq_time_to_end = tensor.matrix( # dtype=dtype, name='seq_time_to_end' #) self.seq_time_to_current = tensor.tensor3(dtype=dtype, name='seq_time_to_current') self.seq_type_event = tensor.imatrix(name='seq_type_event') self.time_since_start_to_end = tensor.vector( dtype=dtype, name='time_since_start_to_end') self.num_sims_start_to_end = tensor.vector( dtype=dtype, name='num_sims_start_to_end') self.seq_mask = tensor.matrix(dtype=dtype, name='seq_mask') self.seq_mask_to_current = tensor.tensor3(dtype=dtype, name='seq_mask_to_current') self.seq_sims_time_to_current = tensor.tensor3( dtype=dtype, name='seq_sims_time_to_current') self.seq_sims_mask_to_current = tensor.tensor3( dtype=dtype, name='seq_sims_mask_to_current') self.seq_sims_mask = tensor.matrix(dtype=dtype, name='seq_sims_mask') # if settings['model'] == 'hawkesinhib': self.hawkes_ctsm = models.HawkesInhibCTSM(settings) list_constrain = [2] elif settings['model'] == 'hawkesinhibscale': self.hawkes_ctsm = models.HawkesInhibCTSM_scale(settings) list_constrain = [0, 3] else: print("called wrong controller") # # self.hawkes_ctsm.compute_loss( #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_mask_to_current, self.seq_sims_time_to_current, self.seq_sims_mask_to_current, self.seq_sims_mask) # assert (settings['optimizer'] == 'adam' or settings['optimizer'] == 'sgd') if settings['optimizer'] == 'adam': self.adam_optimizer = optimizers.Adam(adam_params=None) elif settings['optimizer'] == 'sgd': self.adam_optimizer = optimizers.SGD(adam_params=None) else: print("Choose a optimizer ! ") # self.adam_optimizer.compute_updates(self.hawkes_ctsm.params, self.hawkes_ctsm.grad_params, list_constrain=list_constrain) # print("compiling training function ... ") self.model_learn = theano.function( inputs=[ #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_mask_to_current, self.seq_sims_time_to_current, self.seq_sims_mask_to_current, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ], updates=self.adam_optimizer.updates) print("compiling dev function ... ") self.model_dev = theano.function( inputs=[ #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_mask_to_current, self.seq_sims_time_to_current, self.seq_sims_mask_to_current, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ]) # #self.get_model = self.hawkes_ctsm.get_model self.save_model = self.hawkes_ctsm.save_model
n_epochs=300, batch_size=100, verbose=0) ### Using Adam optimizer ### model = containers.Sequential(layers.Linear(2, 25, with_bias=True), activations.ReLU(), layers.Linear(25, 25, with_bias=True), activations.ReLU(), layers.Linear(25, 25, with_bias=True), activations.ReLU(), layers.Linear(25, 2, with_bias=True), activations.Tanh()) criterion = losses.LossMSE() optimizer = optimizers.Adam(model.param(), learning_rate=0.001, p1=0.9, p2=0.999) model.train() adam_losses = train_model(model, x_train, y_train, optimizer, n_epochs=300, batch_size=100, verbose=0) plt.figure() plt.plot(list(range(300)), sgd_losses) plt.plot(list(range(300)), rmsprop_losses) plt.plot(list(range(300)), adam_losses) plt.xlabel('Epoch')
import optimizers as op import neuralnet as NN from mnist import MNIST mndata = MNIST("../") input_size = 784 mid_size = 200 out_size = 10 epoch = 5000 batch_size = 200 learning_rate = 0.01 sigmoid = False optimizers = [op.SGD(), op.Momentum(), op.AdaGrad(), op.Adam(784, mid_size, 10)] print("loading...") X, Y = mndata.load_training() print("load training data...") X_test, Y_test = mndata.load_testing() print("load testing data...") if not sigmoid: X = np.array(X) / 255 X = X.reshape((X.shape[0], 28 * 28)) Y = np.array(Y) X_test = np.array(X_test) Y_test = np.array(Y_test)
options['n_y'] = np.max(labtrain) + 1 estop = False history_errs = [] history_aucs = [] best_p = None bad_counter = 0 uidx = 0 # number of update done inits = init_params(options, 'all') params = inits tparams = init_tparams(params) before = np.zeros((2, )) _x, _y, f_conv, f_pred_prob, f_pred, _cost = build_model( tparams, options) _lr = tensor.scalar(name='lr') f_cost = theano.function([_x, _y], _cost) f_grad_shared, f_update = optimizers.Adam(tparams, _cost, [_x, _y], _lr) print('Start Pre-Training...') start_time = time.time() try: for eidx in xrange(max_epochs): batch_index = get_minibatches_idx(train.shape[0], batch_size, shuffle=True) for _, train_index in batch_index: uidx = uidx + 1 options['uidx'] = options['uidx'] + 1 x = train[train_index, :, :] y = labtrain[train_index] cost = f_grad_shared(x, y) f_update(lrate, 0.)
noise_id = create_shared_noise.remote() noise = SharedNoiseTable(ray.get(noise_id)) # Create the actors. print("Creating actors.") workers = [ Worker.remote(config, policy_params, env_name, noise_id) for _ in range(num_workers) ] env = gym.make(env_name) sess = utils.make_session(single_threaded=False) policy = policies.MujocoPolicy(env.observation_space, env.action_space, **policy_params) tf_util.initialize() optimizer = optimizers.Adam(policy, stepsize) ob_stat = utils.RunningStat(env.observation_space.shape, eps=1e-2) episodes_so_far = 0 timesteps_so_far = 0 tstart = time.time() while True: step_tstart = time.time() theta = policy.get_trainable_flat() assert theta.dtype == np.float32 # Put the current policy weights in the object store. theta_id = ray.put(theta) # Use the actors to do rollouts, note that we pass in the ID of the policy
continue while True: learning_rate = input('Learning rate desired: ') try: learning_rate = float(learning_rate) break except: continue while True: plot = input('Plot the data? (y/n): ') if plot == 'y': plot = True break elif plot == 'n': plot = False break if plot: plt.scatter(X, Y) plt.show() model, history = optimizers.Adam(X_norm, Y, model, epochs, 8, learning_decay_rate_type='exponential', alpha_0=learning_rate, metrics=metrics, show=True) plt.plot(np.array(range(1, 1 + epochs)), history['loss']) plt.title('Loss') plt.xlabel('epochs') plt.show()
def __init__( self, env_name='HalfCheetah-v1', policy_params=None, num_workers=32, num_deltas=320, deltas_used=320, delta_std=0.02, logdir=None, rollout_length=5000, #1000 step_size=0.01, shift='constant zero', params=None, seed=123, num_states=None): logz.configure_output_dir(logdir) logz.save_params(params) if env_name == 'StickyLiftCubeFree-v0': env = gym.make('LiftCubeFree-v0') import rl2wrapper env = rl2wrapper.StickyActionEnv(env, 10) else: env = gym.make(env_name) env = actionwrapper.stackstatewrapper(env, num_states=num_states) sess = U.single_threaded_session() sess.__enter__() self.timesteps = 0 self.action_size = env.action_space.shape[0] self.ob_size = env.observation_space.shape[0] self.num_deltas = num_deltas self.deltas_used = deltas_used self.rollout_length = rollout_length self.step_size = step_size self.delta_std = delta_std self.logdir = logdir self.shift = shift self.params = params self.max_past_avg_reward = float('-inf') self.num_episodes_used = float('inf') self.num_states = num_states # create shared table for storing noise print("Creating deltas table.") deltas_id = create_shared_noise.remote() self.deltas = SharedNoiseTable(ray.get(deltas_id), seed=seed + 3) print('Created deltas table.') # initialize workers with different random seeds print('Initializing workers.') self.num_workers = num_workers self.workers = [ Worker.remote(seed + 7 * i, env_name=env_name, policy_params=policy_params, deltas=deltas_id, rollout_length=rollout_length, delta_std=delta_std, num_states=num_states) for i in range(num_workers) ] # initialize policy if policy_params['type'] == 'linear': self.policy = LinearPolicy(policy_params) self.w_policy = self.policy.get_weights() elif policy_params['type'] == 'linearbias': self.policy = LinearBiasPolicy(policy_params) self.w_policy = self.policy.get_weights() elif policy_params['type'] == 'mlp': self.policy = MLPPolicy(policy_params) self.w_policy = self.policy.get_weights() elif policy_params['type'] == 'lstm': self.policy = LSTMPolicy(policy_params) self.w_policy = self.policy.get_weights() #elif policy_params['type'] == 'mlp': # import tf_policies # policy_params['ac_space'] = env.action_space # policy_params['ob_space'] = env.observation_space # self.policy = tf_policies.ARS_MLPPolicy(policy_params) # self.w_policy = self.policy.get_weights() else: raise NotImplementedError # initialize optimization algorithm self.optimizer = optimizers.Adam(self.w_policy, self.step_size) print("Initialization of ARS complete.")
else: optim_meta = None if optimize and meta: meta_step = optim_meta.ops_meta_step else: meta_step = [] # optim_adam = optimizers.XHistoryGradNorm(problem, {'limit': 5}) # optim_adam.build() adam_args = config.aug_optim() optim_adam = optimizers.Adam( problem, { 'lr': adam_args['lr_input_optims'], 'beta_1': 0.5, 'beta_2': 0.555, 'eps': 1e-8, 'learn_betas': False, 'decay_learning_rate': adam_args['decay_learning_rate'], 'min_lr': adam_args['min_lr'], 'max_lr': adam_args['max_lr'], 't_max': adam_args['t_max'] }) optim_adam.build() problem_norms = [] if meta: for problem in optim_meta.problems: norm = 0 for variable in problem.variables: norm += tf.norm(variable) problem_norms.append(norm) with tf.Session() as sess:
batch_size = 100 # X_test.shape[0] # reshape to fit the size of array for Convolutinal Layer. ----------- width = xp.sqrt(X.shape[1]).astype(xp.int32).tolist() X_train = X_train.reshape(X_train.shape[0], 1, width, width).astype(xp.float32) X_test = X_test.reshape(X_test.shape[0], 1, width, width).astype(xp.float32) # -------------------------------------------------------------------- epoch_size = train_size // batch_size print('begin training...') network = Mynet( lossfunc=L.Softmax_cross_entropy_with_variational_regularizer( variational=False), # True にすると正則化係数もパラメータになる. optimizer=optimizers.Adam(l1=1e-4, l2=1e-4), batch_size=batch_size, ) loss_history = [] acc_history = [] val_loss_history = [] val_acc_history = [] start = time.time() for index in range(iter_num): batch_choice = xp.random.choice(train_size, batch_size).tolist() x_batch = xp.asarray(X_train[batch_choice]) t_batch = xp.asarray(T_train[batch_choice])
def __init__(self, settings): print("building controller ... ") ''' seq_time_to_current : T * size_batch -- t_i - t_i-1 seq_type_event : (T+1) * size_batch -- k_i seq_time_rep : (T+1) * size_batch * dim_time -- for each data and each time step, track the time features of event k_i time_since_start_to_end : size_batch -- time for seq num_sims_start_to_end : size_batch -- N for each seq seq_mask : T * size_batch -- 1/0 seq_sims_time_to_current : N * size_batch -- s_j - t_i seq_sims_index_in_hidden : N * size_batch -- int32 seq_sims_mask : N * size_batch -- 1/0 ''' #self.seq_time_to_end = tensor.matrix( # dtype=dtype, name='seq_time_to_end' #) self.seq_time_to_current = tensor.matrix(dtype=dtype, name='seq_time_to_current') self.seq_type_event = tensor.imatrix(name='seq_type_event') #self.seq_time_rep = tensor.tensor3( # dtype=dtype, name='seq_time_rep' #) self.seq_time_values = tensor.matrix(dtype=dtype, name='seq_time_values') # self.time_since_start_to_end = tensor.vector( dtype=dtype, name='time_since_start_to_end') self.num_sims_start_to_end = tensor.vector( dtype=dtype, name='num_sims_start_to_end') self.seq_mask = tensor.matrix(dtype=dtype, name='seq_mask') self.seq_sims_time_to_current = tensor.matrix( dtype=dtype, name='seq_sims_time_to_current') self.seq_sims_index_in_hidden = tensor.imatrix( name='seq_sims_index_in_hidden') self.seq_sims_mask = tensor.matrix(dtype=dtype, name='seq_sims_mask') self.time_diffs = tensor.vector(dtype=dtype, name='time_diffs') # # if settings['model'] == 'neuraladapttime': self.hawkes_ctsm = models.NeuralHawkesAdaptiveBaseCTSM_time( settings) list_constrain = [] elif settings['model'] == 'neuraladapttimescale': self.hawkes_ctsm = models.NeuralHawkesAdaptiveBaseCTSM_time_scale( settings) list_constrain = [0] elif settings['model'] == 'neuralreduce': self.hawkes_ctsm = models.NeuralHawkesAdaptiveBaseCTSM_time_scale_r( settings) list_constrain = [0] elif settings['model'] == 'conttime': self.hawkes_ctsm = models.NeuralHawkesCTLSTM(settings) list_constrain = [0] else: print("called wrong controller") # assert (settings['loss_type'] == 'loglikehood' or settings['loss_type'] == 'prediction') # if settings['loss_type'] == 'loglikehood': print("train with log-likelihood ... ") self.hawkes_ctsm.compute_loss( #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, #self.seq_time_rep, self.seq_time_values, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask) else: print("train with prediction ... ") #TODO: need to add switch for less memory #or faster speed #self.hawkes_ctsm.compute_prediction_loss( self.hawkes_ctsm.compute_prediction_loss_lessmem( self.seq_type_event, self.seq_time_values, self.seq_mask, self.time_diffs) # #self.hawkes_ctsm.compute_prediction( # self.seq_type_event, # self.seq_time_values, # self.seq_mask, # self.time_diffs #) # assert (settings['optimizer'] == 'adam' or settings['optimizer'] == 'sgd') if settings['optimizer'] == 'adam': self.adam_optimizer = optimizers.Adam(adam_params=None) elif settings['optimizer'] == 'sgd': self.adam_optimizer = optimizers.SGD(adam_params=None) else: print("Choose a optimizer ! ") # if 'learn_rate' in settings: print("learn rate is set to : ", settings['learn_rate']) self.adam_optimizer.set_learn_rate(settings['learn_rate']) # self.adam_optimizer.compute_updates(self.hawkes_ctsm.params, self.hawkes_ctsm.grad_params, list_constrain=list_constrain) # in this version, no hard constraints on parameters # if settings['loss_type'] == 'loglikehood': print("optimize loglikehood ... ") print("compiling training function ... ") self.model_learn = theano.function( inputs=[ self.seq_time_to_current, self.seq_type_event, self.seq_time_values, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ], updates=self.adam_optimizer.updates, on_unused_input='ignore') print("compiling dev function ... ") self.model_dev = theano.function( inputs=[ #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, #self.seq_time_rep, self.seq_time_values, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events, self.hawkes_ctsm.last_hidden_t, self.hawkes_ctsm.last_cell_t, self.hawkes_ctsm.last_cell_target, self.hawkes_ctsm.last_cell, self.hawkes_ctsm.last_cell_decay, self.hawkes_ctsm.last_gate_output ], on_unused_input='ignore') if settings['predict_lambda']: print("compiling dev function for intensity computation ... ") self.hawkes_ctsm.compute_lambda(self.seq_type_event, self.seq_time_values, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask) self.model_dev_lambda = theano.function( inputs=[ self.seq_type_event, self.seq_time_values, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.lambda_samples, self.hawkes_ctsm.num_of_samples ], on_unused_input='ignore') else: print("optimize prediction ... ") print("compiling training function ... ") self.model_learn = theano.function( inputs=[ self.seq_type_event, self.seq_time_values, self.seq_mask, self.time_diffs ], outputs=[ self.hawkes_ctsm.log_likelihood_type_predict, self.hawkes_ctsm.num_of_errors, self.hawkes_ctsm.square_errors, self.hawkes_ctsm.num_of_events #self.hawkes_ctsm.abs_grad_params ], updates=self.adam_optimizer.updates, on_unused_input='ignore') print("compiling dev function ... ") self.model_dev = theano.function( inputs=[ self.seq_type_event, self.seq_time_values, self.seq_mask, self.time_diffs ], outputs=[ self.hawkes_ctsm.log_likelihood_type_predict, self.hawkes_ctsm.num_of_errors, self.hawkes_ctsm.square_errors, self.hawkes_ctsm.num_of_events #self.hawkes_ctsm.abs_grad_params # ], on_unused_input='ignore') # # self.get_model = self.hawkes_ctsm.get_model self.save_model = self.hawkes_ctsm.save_model
def __init__(self, env_name='HalfCheetah-v1', policy_params=None, num_workers=32, num_deltas=320, deltas_used=320, delta_std=0.02, logdir=None, rollout_length=1000, step_size=0.01, shift='constant zero', params=None, seed=123): logz.configure_output_dir(logdir) logz.save_params(params) env = gym.make(env_name) self.timesteps = 0 self.action_size = env.action_space.shape[0] self.ob_size = env.observation_space.spaces['observation'].shape[ 0] + env.observation_space.spaces['desired_goal'].shape[0] self.num_deltas = num_deltas self.deltas_used = deltas_used self.rollout_length = rollout_length self.step_size = step_size self.delta_std = delta_std self.logdir = logdir self.shift = shift self.params = params self.max_past_avg_reward = float('-inf') self.num_episodes_used = float('inf') # create shared table for storing noise print("Creating deltas table.") deltas_id = create_shared_noise.remote() self.deltas = SharedNoiseTable(ray.get(deltas_id), seed=seed + 3) print('Created deltas table.') # initialize workers with different random seeds print('Initializing workers.') self.num_workers = num_workers self.workers = [ Worker.remote(seed + 7 * i, env_name=env_name, policy_params=policy_params, deltas=deltas_id, rollout_length=rollout_length, delta_std=delta_std) for i in range(num_workers) ] # initialize policy if policy_params['type'] == 'linear': self.policy = LinearPolicy(policy_params) self.w_policy = self.policy.get_weights() elif policy_params['type'] == 'nn': self.policy = NNPolicy(policy_params) self.w_policy = self.policy.get_weights() else: raise NotImplementedError # initialize optimization algorithm # self.optimizer = optimizers.SGD(self.w_policy, self.step_size) # @avemula self.optimizer = optimizers.Adam(self.w_policy, self.step_size) print("Initialization of ARS complete.")
def __init__(self, settings): print("building controller ... ") ''' seq_time_to_current : T * size_batch -- t_i - t_i-1 seq_type_event : (T+1) * size_batch -- k_i seq_time_rep : (T+1) * size_batch * dim_time -- for each data and each time step, track the time features of event k_i time_since_start_to_end : size_batch -- time for seq num_sims_start_to_end : size_batch -- N for each seq seq_mask : T * size_batch -- 1/0 seq_sims_time_to_current : N * size_batch -- s_j - t_i seq_sims_index_in_hidden : N * size_batch -- int32 seq_sims_mask : N * size_batch -- 1/0 ''' #self.seq_time_to_end = tensor.matrix( # dtype=dtype, name='seq_time_to_end' #) self.seq_time_to_current = tensor.matrix(dtype=dtype, name='seq_time_to_current') self.seq_type_event = tensor.imatrix(name='seq_type_event') #self.seq_time_rep = tensor.tensor3( # dtype=dtype, name='seq_time_rep' #) self.seq_time_values = tensor.matrix(dtype=dtype, name='seq_time_values') # self.time_since_start_to_end = tensor.vector( dtype=dtype, name='time_since_start_to_end') self.num_sims_start_to_end = tensor.vector( dtype=dtype, name='num_sims_start_to_end') self.seq_mask = tensor.matrix(dtype=dtype, name='seq_mask') self.seq_sims_time_to_current = tensor.matrix( dtype=dtype, name='seq_sims_time_to_current') self.seq_sims_index_in_hidden = tensor.imatrix( name='seq_sims_index_in_hidden') self.seq_sims_mask = tensor.matrix(dtype=dtype, name='seq_sims_mask') # self.hawkes_ctsm = models.GeneralizedNeuralHawkesCTSM_time(settings) # self.hawkes_ctsm.compute_loss( #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, #self.seq_time_rep, self.seq_time_values, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask) # assert (settings['optimizer'] == 'adam' or settings['optimizer'] == 'sgd') if settings['optimizer'] == 'adam': self.adam_optimizer = optimizers.Adam(adam_params=None) elif settings['optimizer'] == 'sgd': self.adam_optimizer = optimizers.SGD(adam_params=None) else: print("Choose a optimizer ! ") # self.adam_optimizer.compute_updates(self.hawkes_ctsm.params, self.hawkes_ctsm.grad_params, list_constrain=[]) # in this version, no hard constraints on parameters # print("compiling training function ... ") self.model_learn = theano.function( inputs=[ #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, #self.seq_time_rep, self.seq_time_values, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ], updates=self.adam_optimizer.updates) print("compiling dev function ... ") self.model_dev = theano.function( inputs=[ #self.seq_time_to_end, self.seq_time_to_current, self.seq_type_event, #self.seq_time_rep, self.seq_time_values, self.time_since_start_to_end, self.num_sims_start_to_end, self.seq_mask, self.seq_sims_time_to_current, self.seq_sims_index_in_hidden, self.seq_sims_mask ], outputs=[ self.hawkes_ctsm.log_likelihood_seq, self.hawkes_ctsm.log_likelihood_time, self.hawkes_ctsm.log_likelihood_type, self.hawkes_ctsm.num_of_events ]) # #self.get_model = self.hawkes_ctsm.get_model self.save_model = self.hawkes_ctsm.save_model
plt.plot(X_test, y_test) plt.plot(X_test, predictions) plt.show() ''' '' EPOCHS = 10001 LEARNING_RATE = 0.05 X_train, y_train = spiral_data(samples=100, classes=3) X_val, y_val = spiral_data(samples=100, classes=3) model = network.NeuralNetwork() model.add_layer( layers.Dense(2, 64, weight_regularizer_l2=0.000005, bias_regularizer_l2=0.000005)) model.add_layer(activations.ReLU()) model.add_layer(layers.Dropout(rate=0.2)) model.add_layer(layers.Dense(64, 3)) model.add_layer(activations.Softmax()) model.set(loss=losses.CategoricalCrossentropy(), optimizier=optimizers.Adam(learning_rate=LEARNING_RATE), accuracy=metrics.CategoricalAccuracy()) model.fit(X_train, y_train, epochs=EPOCHS, validation_data=(X_val, y_val))