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