def __init__(self, word_embeddings_dim, tag_embeddings_dim, vocabulary_size, tag_uniqueCount, label_uniqueCount, pretrainedWordEmbeddings=None, pretrainedTagEmbeddings=None):
super().__init__()
self.word_embeddings = nn.Embedding(vocabulary_size, word_embeddings_dim)
if pretrainedWordEmbeddings.any():
assert pretrainedWordEmbeddings.shape == (vocabulary_size, word_embeddings_dim)
self.word_embeddings.weight.data.copy_(torch.from_numpy(pretrainedWordEmbeddings))
self.tag_embeddings = nn.Embedding(tag_uniqueCount, tag_embeddings_dim)
if pretrainedTagEmbeddings.any():
assert pretrainedTagEmbeddings.shape == (tag_uniqueCount, tag_embeddings_dim)
self.tag_embeddings.weight.data.copy_(torch.from_numpy(pretrainedTagEmbeddings))
# Save computation time by not training already trained word vectors
# disableTrainingForEmbeddings(self.word_embeddings, self.tag_embeddings)
# Now we need to train the embeddings for <root> and <unk>
self.inputSize = word_embeddings_dim + tag_embeddings_dim # The number of expected features in the input x
self.hiddenSize = self.inputSize #* 2 # 512? is this the same as outputSize?
self.nLayers = 2
self.biLstm = nn.LSTM(self.inputSize, self.hiddenSize, self.nLayers, bidirectional=True)
self.nDirections = 2
self.batch = 1 # this is per recommendation
# Input size of the MLP for arcs scores is the size of the output from previous step concatenated with another of the same size
biLstmOutputSize = self.hiddenSize * self.nDirections
mlpForScoresInputSize = biLstmOutputSize * 2
self.mlpArcsScores = MLP(mlpForScoresInputSize, hidden_size=mlpForScoresInputSize, output_size=1)
# MLP for labels
self.label_uniqueCount = label_uniqueCount
self.mlpLabels = MLP(mlpForScoresInputSize, hidden_size=mlpForScoresInputSize, output_size=self.label_uniqueCount)
def add_models(self,
input_dims: list = None,
pose_labels: list = None,
freeze=False):
n = len(self.models) + 1
if pose_labels is not None:
self.models += [
MLP(config=self.config,
dimensions=[input_dims[i]],
pose_labels=pose_labels[i],
name="M" + str(i + n),
single_module=0) for i in range(len(input_dims))
]
else:
self.models += [
MLP(config=self.config,
dimensions=[input_dims[i]],
name="M" + str(i + n),
single_module=0) for i in range(len(input_dims))
]
if freeze:
for model in self.active_models:
model.freeze(True)
self.active_models = self.models[n - 1:]
self.input_dims = input_dims
else:
self.active_models = self.models
self.input_dims += input_dims
self.input_slice = [0] + list(accumulate(add, self.input_dims))
def __init__(self,
config: dict = None,
Model=None,
pose_autoencoder=None,
feature_dims=None,
input_slicers: list = None,
output_slicers: list = None,
train_set=None,
val_set=None,
test_set=None,
name="MotionGeneration"):
super().__init__()
self.feature_dims = feature_dims
self.config = config
self.loss_fn = config[
"loss_fn"] if "loss_fn" in config else nn.functional.mse_loss
self.opt = config[
"optimizer"] if "optimizer" in config else torch.optim.Adam
self.scheduler = config["scheduler"] if "scheduler" in config else None
self.scheduler_param = config[
"scheduler_param"] if "scheduler_param" in config else None
self.batch_size = config["batch_size"]
self.learning_rate = config["lr"]
self.best_val_loss = np.inf
self.phase_smooth_factor = 0.9
self.pose_autoencoder = pose_autoencoder if pose_autoencoder is not None else \
MLP(config=config, dimensions=[feature_dims["pose_dim"]], name="PoseAE")
self.use_label = pose_autoencoder is not None and pose_autoencoder.use_label
cost_hidden_dim = config["cost_hidden_dim"]
self.cost_encoder = MLP(config=config,
dimensions=[
feature_dims["cost_dim"], cost_hidden_dim,
cost_hidden_dim, cost_hidden_dim
],
name="CostEncoder",
single_module=-1)
self.generationModel = Model(config=config,
dimensions=[
feature_dims["g_input_dim"],
feature_dims["g_output_dim"]
],
phase_input_dim=feature_dims["phase_dim"])
self.input_dims = input_slicers
self.output_dims = output_slicers
self.in_slices = [0] + list(accumulate(add, input_slicers))
self.out_slices = [0] + list(accumulate(add, output_slicers))
self.train_set = train_set
self.val_set = val_set
self.test_set = test_set
self.name = name
def experiment_train_val_seq_batch_mlp():
use_validation_set = False
case = 1
[inputs, inputs_labels, input_validation,
input_validation_labels] = Utils.create_non_linearly_separable_data_2(
use_validation_set=use_validation_set, case=case)
num_hidden_nodes_layer_1 = 20
num_iterations = 1000
learning_rate = 0.002
verbose = False
mlp_batch = MLP(inputs=inputs,
inputs_labels=inputs_labels,
input_validation=input_validation,
input_validation_labels=input_validation_labels,
num_nodes_hidden_layer=num_hidden_nodes_layer_1,
num_iterations=num_iterations,
learning_rate=learning_rate,
batch_train=True,
verbose=verbose)
[_, _, mse_batch] = mlp_batch.fit()
train_batch_mse_batch = mlp_batch.mse
eval_batch_mse_batch = mlp_batch.validation_mse
Utils.plot_decision_boundary_mlp(
inputs, inputs_labels, mlp_batch,
'MLP with learning rate {0}, iterations {1} , num hidden nodes {2}'.
format(learning_rate, num_iterations, num_hidden_nodes_layer_1))
mlp_seq = MLP(inputs=inputs,
inputs_labels=inputs_labels,
input_validation=input_validation,
input_validation_labels=input_validation_labels,
num_nodes_hidden_layer=num_hidden_nodes_layer_1,
num_iterations=num_iterations,
learning_rate=learning_rate,
batch_train=False,
verbose=verbose)
[_, _, mse_seq] = mlp_seq.fit()
train_seq_mse_batch = mlp_seq.mse
eval_seq_mse_batch = mlp_seq.validation_mse
mse = [
train_batch_mse_batch, train_seq_mse_batch, eval_batch_mse_batch,
eval_seq_mse_batch
]
legend_names = ['train batch', 'train seq', 'eval batch', 'eval seq']
Utils.plot_error_with_epochs(
mse,
legend_names=legend_names,
num_epochs=num_iterations,
title='MLP with lr = {0}, iterations = {1} , hidden nodes = {2} '.
format(learning_rate, num_iterations, num_hidden_nodes_layer_1))
def test(args, device):
full_data = get_data_loader(args)
if args.model_type == "CNN":
from CNN import CNN
model = CNN(args).to(device)
elif args.model_type == "MLP":
from MLP import MLP
model = MLP(args).to(device)
elif args.model_type == "LSTM":
from LSTM import LSTM
model = LSTM(args).to(device)
optimiser = optim.Adam(
model.parameters(), lr=args.learning_rate)
state = torch.load(args.model_path, map_location=device)
model.load_state_dict(state['model'])
optimiser.load_state_dict(state['optimiser'])
total_difference = 0
n = 0
for batch_num, data in enumerate(full_data):
x, y = data[0].float().to(device), data[1].float().to(device)
num_of_predictions = x.shape[0]
pred = model(x)
pred = pred.reshape(y.shape)
total_difference += sum((abs(pred - y)/y) * 100)
n += num_of_predictions
return total_difference/n
def __init__(self, env, alpha, gamma, episode_num, target_reward,
step_count, minbatch, memory_size, flag):
self.env = env
self.alpha = alpha
self.gamma = gamma
self.episode_num = episode_num
self.target_reward = target_reward
self.step_count = step_count
# self.test_step=test_step
self.minbatch = minbatch
self.memory_size = memory_size
self.flag = flag
self.Q = MLP()
self.state_dim = env.observation_space.shape[0]
self.action_dim = env.action_space.spaces[
0].n * env.action_space.spaces[1].n
# self.action_dim = env.action_space.n
self.Q.creat2(self.state_dim, env.action_space.spaces[0].n,
env.action_space.spaces[1].n)
self.memory_num = 0
self.memory = np.zeros((memory_size, self.state_dim * 2 + 4))
self.optimizer = torch.optim.Adam(self.Q.parameters(), lr=alpha)
self.loss_func = nn.MSELoss()
def main():
"""
Run the test case XOR
"""
print("...Reading dataset")
dataset = load_dataset("datasets/xor.dat")
print("...done!")
print("...Spliting the dataset")
training_samples, testing_samples, labels_train, labels_test = split_dataset(
dataset)
print("...done!")
print("...Creating the classifier")
clf = MLP(input_layer=2, hidden=2, output=1)
print("...done!")
print("...Fiting the clf")
clf.fit(training_samples, labels_train, verbose_error=True)
print("...done!")
print("...Made a prediction")
pred = clf.predict(testing_samples)
print("...done!")
print('Convergence: with MSE:{}'.format(clf.error))
print(clf)
print(
pd.DataFrame.from_items([('Expected', labels_test),
('Obtained', pred)]))
clf.plot_errors()
def __init__(self):
self.type = None
self.nn = MLP()
self.training_method = None
self.activation_function = None
self.dropout_rate = 0.0
self.training = True
self.learning_rate = 0.1
self.fitness_threshold = 0.75
self.epoch_threshold = -1
self.batch_size = 100
self.shuffle_rate = 2500
self.display_step = 1000
self.epoch = 0
self.layers = []
self.data_set = None
self.bed = BinaryEncoderDecoder()
self.utils = Utilities()
self.debug_mode = False
# Plotting variables
self.losses = []
self.fitnesses = []
self.iterations = []
self.save_location = './nn/log/'
def test_units_accuracy(units, steps, epochs):
accuracies = []
units = range(1, units, steps)
for unit in units:
mlp = MLP(ReLU, X_train.shape[1], [unit])
accuracies.append(test_mlp_model(mlp, epochs, 30, plot=False))
plot_unit_accuracy(accuracies, units)
def mlp_test(test_set, Model, n_input=2030, n_output=150, n_hidden=50):
datasets = load_data(test_set, test_set, test_set)
test_set_x, test_set_y = datasets[0]
index = T.lscalar() # index to a [mini]batch
x = T.vector('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
rng = numpy.random.RandomState(1234)
# construct the MLP class
classifier = MLP(rng=rng,
input=x,
n_in=n_input,
n_hidden=n_hidden,
n_out=n_output,
Model=Model)
#classifier.hiddenLayer.__setstate__((Model['hidden_W'], Model['hidden_b']))
#classifier.logRegressionLayer.__setstate__((Model['logRegression_W'], Model['logRegression_b']))
test_model = theano.function(inputs=[index],
outputs=classifier.predictAll,
givens={
x: test_set_x[index],
})
out = test_model(0).tolist()
return out
def Main():
x_train = pd.read_csv('Dataset/xtrain_3spirals.txt', sep=' ', header=None)
x_test = pd.read_csv('Dataset/xtest_3spirals.txt', sep=' ', header=None)
d_train = pd.read_csv('Dataset/dtrain_3spirals.txt', sep=',', header=None)
d_test = pd.read_csv('Dataset/dtest_3spirals.txt', sep=',', header=None)
## Aplication of MLP algorithm
mlp = MLP(15000, 0.15, 0.000001, [4, 3], 0.5)
mlp.train(x_train.to_numpy(), d_train.to_numpy())
new_classes = mlp.application(x_test.to_numpy())
comparative = np.concatenate((d_test.to_numpy(), new_classes), 1)
print("Matrix of comparative between classes")
print(comparative)
print("------------------------------")
hit_table = np.zeros((len(new_classes), 1))
for row in range(len(new_classes)):
if all(d_test.to_numpy()[row] == new_classes[row]):
hit_table[row] = 1
tax_hit = sum(hit_table) / len(new_classes)
print("------------------------------")
print("Matrix of hits")
print(hit_table)
print("------------------------------")
print("Tax of hits: " + str(tax_hit))
def __init__(self,
config: dict = None,
input_dims: list = None,
pose_labels=None,
train_set=None,
val_set=None,
test_set=None,
name: str = "model",
save_period=5,
workers=6):
super(RBF, self).__init__()
M = len(input_dims)
self.name = name
self.input_dims = input_dims
self.input_slice = [0] + list(accumulate(add, input_dims))
self.act = nn.ELU
self.save_period = save_period
self.workers = workers
self.pose_labels = pose_labels if pose_labels is not None else [
None for _ in range(M)
]
self.config = config
self.basis_func = basis_func_dict()[config["basis_func"]]
self.hidden_dim = config["hidden_dim"]
self.keep_prob = config["keep_prob"]
self.k = config["k"]
self.learning_rate = config["lr"]
self.batch_size = config["batch_size"]
self.loss_fn = config[
"loss_fn"] if "loss_fn" in config else nn.functional.mse_loss
self.opt = config[
"optimizer"] if "optimizer" in config else torch.optim.Adam
self.scheduler = config["scheduler"] if "scheduler" in config else None
self.scheduler_param = config[
"scheduler_param"] if "scheduler_param" in config else None
self.models = [
MLP(config=config,
dimensions=[input_dims[i]],
pose_labels=self.pose_labels[i],
name="M" + str(i),
single_module=0) for i in range(M)
]
self.active_models = self.models
self.cluster_model = RBF_Layer(in_features=self.k,
out_features=self.k,
basis_func=self.basis_func)
self.train_set = train_set
self.val_set = val_set
self.test_set = test_set
self.best_val_loss = np.inf
def __init__(self, x, model_file):
"""
Sampling works as follows.
You feed it a model and a dataset, and model_files.
The model_files allow you to load in models from different checkpoints.
A feed through function is compiled that samples from the test dataset.
It calculates the error and the output for each element in test dataset.
It generates two distributions -- output for signal, and output for background.
args:
model: MLP object
dataset Dataset object
model_files: list of files corresponding to saved models
"""
self.model_file = model_file
self.param = self.detect_params(self.model_file)
self.dataset = Dataset(self.param['dataset'])
self.dataset.set_indexing(self.param['indexing'])
self.shared_train_x = self.dataset.train_x
self.shared_train_y = self.dataset.train_y
self.shared_test_x = self.dataset.test_x
self.shared_test_y = self.dataset.test_y
try:
self.train_labels = self.dataset.train_labels
self.test_labels = self.dataset.test_labels
except AttributeError:
print(
"You're used a dataset without labels. You won't be able to call gen_labeled_outputs"
)
mlp = MLP(x, [self.param['h0'], self.param['h1'], 2],
np.random.RandomState(1234),
transfer_func=T.nnet.relu)
mlp.load_params(self.model_file, mode='hdf5')
self.model = mlp
self.predicted = dict()
def load_pretrain_weights(self):
"""Loading weights from trained MLP model & GMF model"""
config = self.config
config['latent_dim'] = config['latent_dim_mlp']
mlp_model = MLP(config)
if config['use_cuda'] is True:
mlp_model.cuda()
resume_checkpoint(mlp_model,
model_dir=config['pretrain_mlp'],
device_id=config['device_id'])
self.embedding_user_mlp.weight.data = mlp_model.embedding_user.weight.data
self.embedding_item_mlp.weight.data = mlp_model.embedding_item.weight.data
for idx in range(len(self.fc_layers)):
self.fc_layers[idx].weight.data = mlp_model.fc_layers[
idx].weight.data
config['latent_dim'] = config['latent_dim_mf']
gmf_model = GMF(config)
if config['use_cuda'] is True:
gmf_model.cuda()
resume_checkpoint(gmf_model,
model_dir=config['pretrain_mf'],
device_id=config['device_id'])
self.embedding_user_mf.weight.data = gmf_model.embedding_user.weight.data
self.embedding_item_mf.weight.data = gmf_model.embedding_item.weight.data
self.affine_output.weight.data = 0.5 * torch.cat([
mlp_model.affine_output.weight.data,
gmf_model.affine_output.weight.data
],
dim=-1)
self.affine_output.bias.data = 0.5 * (
mlp_model.affine_output.bias.data +
gmf_model.affine_output.bias.data)
def main(args):
#建立文件夹
result_path = os.path.join(args.output_path, "final_result")
check_dir(args.output_path)
check_dir(result_path)
#设置gpu
torch.cuda.set_device(args.gpu_id) #GPU
#加载数据
train_set = MySet(args.txt_path, mode="train")
val_set = MySet(args.txt_path, mode="val")
train_loader = DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True)
val_loader = DataLoader(val_set, batch_size=args.batch_size, shuffle=False)
#网络模型
net = MLP(args)
net.cuda() #GPU
#使用Adam优化器和交叉熵损失函数
optimizer = torch.optim.Adam(net.parameters(),
lr=args.lr,
weight_decay=1e-4)
cost = torch.nn.CrossEntropyLoss()
epoch_loss, epoch_acc, val_loss, val_acc = [], [], [], []
#epoch循环
t0 = time.time()
for epoch in range(args.epoch):
t_loss, t_acc = train_epoch(net, train_loader, optimizer, cost)
epoch_loss.append(t_loss)
epoch_acc.append(t_acc)
v_loss, v_acc = val_epoch(net, val_loader, cost)
val_acc.append(v_acc)
val_loss.append(v_loss)
#画出训练集和测试集的loss及acc
plot(epoch_acc, val_acc, result_path, 'train_acc', 'val_acc',
args.batch_size, 'acc')
plot(epoch_loss, val_loss, result_path, 'train_loss', 'val_loss',
args.batch_size, 'loss')
info = [str(epoch).zfill(3), t_loss, v_acc]
print("Epoch: {} | train Loss: {:.4f} val ACC: {:.4f}".format(*info))
t1 = time.time()
print("Optimization Finished! Cost time:{:.1f} minutes".format(
(t1 - t0) / 60))
print("The final acc=%g" % v_acc)
#保存最终模型
state = net.state_dict()
torch.save(state, os.path.join(result_path, "Network_final.pth.gz"))
def main(client_id):
while True:
try:
response = requests.get(url + 'deepLearning')
json_data = json.loads(response.text)
# response_message = response.content().decode('utf-8')
image_file_index = int(json_data['image_file_index'])
epoch_number = int(json_data['epoch_number'])
print('image_index_file: ' + str(image_file_index))
print('epoch_number: ' + str(epoch_number))
mode = str(json_data['mode'])
print('mode: ' + mode)
if mode == 'stop':
return
if mode == 'wait':
time.sleep(1.5)
continue
client = MongoClient(
'mongodb://*****:*****@ds111529.mlab.com:11529/primre')
_db = client.primre
print('start download network')
try:
network = _db.Network.find_one({'id': 1})
l1_w_list = network['l1_list']
l2_w_list = network['l2_list']
except:
_db.GlobalParameters.update_one(
{'id': 1}, {'$inc': {
'image_file_index': -1
}})
continue
print('finish download network')
lin_neural_network_l1 = L.Linear(784, 300)
lin_neural_network_l2 = L.Linear(300, 10)
for i in range(300):
for j in range(784):
lin_neural_network_l1.W.data[i][j] = l1_w_list[i][j]
for i in range(10):
for j in range(300):
lin_neural_network_l2.W.data[i][j] = l2_w_list[i][j]
mlp = MLP(lin_neural_network_l1, lin_neural_network_l2)
file_images_name = '~/images_train/image_' + str(image_file_index)
file_labels_name = '~/labels_train/label_' + str(image_file_index)
if mode == 'test':
file_images_name = '~/images_test/images_' + str(
image_file_index)
file_labels_name = '~/labels_test/label_' + str(
image_file_index)
if mode == "train":
train(_db, client_id, mlp, file_images_name, file_labels_name,
l1_w_list, l2_w_list)
else:
validate_test(_db, mode, mlp, epoch_number, file_images_name,
file_labels_name)
except:
continue
def test_depth_accuracy(depth, epochs):
accuracies = []
depths = range(depth)
for depth in depths:
print(f"MLP depth: {depth}")
mlp = MLP(ReLU, X_train.shape[1], [128] * depth)
accuracies.append(test_mlp_model(mlp, epochs, 30, plot=False))
plot_depth_accuracy(accuracies, depths)
def test():
model_to_be_restored = MLP()
checkpoint = tf.train.Checkpoint(myAwesomeModel=model_to_be_restored)
checkpoint.restore(tf.train.latest_checkpoint('./check_point'))
y_pred = np.argmax(model_to_be_restored.predict(data_loader.test_data),
axis=-1)
print("test accuracy: %f" %
(sum(y_pred == data_loader.test_label) / data_loader.num_test_data))
def tune(n):
model = MLP((4, ), training_epochs=5000, beta=betas[n], debug=False)
m = Model(model, transfs, gen_x, gen_y, RMSE)
window = [1, 4, 12]
ret = m.expanding_window(X_train, y_train, TRAIN_OFFSET, window, 'dynamic')
print(betas[n])
return betas[n], ret[1][3].iloc[-1, 0], ret[1][0], ret[4][0], ret[12][0]
def get_mlp(self):
try:
hidden_nodes = int(self.hidden_nodes_input.get())
learning_rate = float(self.learning_rate_input.get())
return MLP(input_nodes=784, hidden_nodes=hidden_nodes,
output_nodes=10, learning_rate=learning_rate)
except ValueError:
return None
def __init__(self, img=None, model_path='my_model.npz'):
self.origin_img = img
self.preprocess_img = None
self.detected_number = None
self.number_model_path = model_path
self.net = L.Classifier(MLP(1000, 10))
self.data_directory = "data"
self.img_directory = "imgs" # 画像を保管するディレクトリ
self.setup()
def experiment_learning_curves_error():
train_test = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
use_validation_set = True
num_hidden_nodes_layer_1 = 20
num_iterations = 1000
learning_rate = 0.001
verbose = False
cases = [1, 2, 3, 4]
train_MSE = []
val_MSE = []
for case in cases:
[inputs, inputs_labels, input_validation,
input_validation_labels] = Utils.create_non_linearly_separable_data_2(
use_validation_set=use_validation_set, case=case)
print(case)
current_train = []
current_validation = []
for check in train_test:
X_train, X_test, y_train, y_test = train_test_split(
inputs.T, inputs_labels, test_size=check, random_state=42)
mlp_batch = MLP(inputs=X_train.T,
inputs_labels=y_train,
input_validation=input_validation,
input_validation_labels=input_validation_labels,
num_nodes_hidden_layer=num_hidden_nodes_layer_1,
num_iterations=num_iterations,
learning_rate=learning_rate,
batch_train=True,
verbose=verbose)
[_, _, mse_batch] = mlp_batch.fit()
current_train.append(mlp_batch.mse[-1])
current_validation.append(mlp_batch.validation_mse[-1])
train_MSE.append(current_train)
val_MSE.append(current_validation)
legend_names = [
'train mse error case 1', 'train mse error case 2',
'train mse error case 3', 'train mse error case 4',
'validation mse error case 1', 'validation mse error case 2',
'validation mse error case 3', 'validation mse error case 4'
]
Utils.plot_learning_curves(
train_MSE,
legend_names=legend_names,
train_size=train_test,
title='Learning curve with lr = {0}, iterations = {1} '.format(
learning_rate, num_iterations),
loss=val_MSE)
def generateModel(learningRate):
layer0 = Layer(4, 0, 4, ActivationFunction.linear)
layer1 = Layer(3, 1, 4, ActivationFunction.sigmoid)
layer2 = Layer(3, 2, 3, ActivationFunction.sigmoid)
layers = []
layers.append(layer0)
layers.append(layer1)
layers.append(layer2)
return MLP(layers, learningRate)
def tune_learning_rate():
accuracies = []
lrs = [0.001, 0.01, 0.1] # Figure10, 11, 12
for lr in lrs:
print(
"\n\nmlp a 2 hidden layers having 128 units with ReLU activation")
print(f"minibatch sizes: 30, learning_rate={lr}")
mlp = MLP(ReLU, X_train.shape[1], [128, 128], lr=lr)
accuracies.append(test_mlp_model(mlp, 30, 30))
plot_vs_accuracy(accuracies, lrs, "Learning rate")
def tune_batchsize():
accuracies = []
bsizes = [10, 100, 1000] # Fig15, 16, 17
for bsize in bsizes:
print(
"\n\nmlp a 2 hidden layers having 128 units with ReLU activation")
print(f"minibatch sizes: {bsize}, learning_rate={0.1}")
mlp = MLP(ReLU, X_train.shape[1], [128, 128])
accuracies.append(test_mlp_model(mlp, 30, bsize))
plot_vs_accuracy(accuracies, bsizes, "Batch size")
def initialize_model(args):
if args.model == 'ridge':
return Ridge()
elif args.model == 'mlp':
return MLP(n_input=x.shape[-1], n_mid=args.n_mid, lr=args.lr, n_output=t.shape[-1], batch_size=500,
shuffle_batches=args.shuffle, drop=args.drop, n_epochs=args.n_epochs, toplot=False)
elif args.model == 'lstm':
return LSTM(n_input=x.shape[-1], n_mid=args.n_mid, lr=args.lr, w_decay=0., n_output=t.shape[-1],
batch_size=200, n_back=args.n_back, drop=args.drop, n_epochs=args.n_epochs, toplot=False)
else:
raise Exception('Unknown model')
def experiment_train_validation_nodes():
use_validation_set = True
num_iterations = 1000
learning_rate = 0.002
verbose = False
nodes = [1, 5, 10, 20, 25]
cases = [1, 2, 3, 4]
train_MSE = []
val_MSE = []
for case in cases:
print(case)
[inputs, inputs_labels, input_validation,
input_validation_labels] = Utils.create_non_linearly_separable_data_2(
use_validation_set=use_validation_set, case=case)
current_mse = []
current_val_mse = []
for node in nodes:
mlp_batch = MLP(inputs=inputs,
inputs_labels=inputs_labels,
input_validation=input_validation,
input_validation_labels=input_validation_labels,
num_nodes_hidden_layer=node,
num_iterations=num_iterations,
learning_rate=learning_rate,
batch_train=True,
verbose=verbose)
[_, _, mse_batch] = mlp_batch.fit()
current_mse.append(mlp_batch.mse[-1])
current_val_mse.append(mlp_batch.validation_mse[-1])
train_MSE.append(current_mse)
val_MSE.append(current_val_mse)
legend_names = [
'train mse error case 1', 'train mse error case 2',
'train mse error case 3', 'train mse error case 4',
'validation mse error case 1', 'validation mse error case 2',
'validation mse error case 3', 'validation mse error case 4'
]
Utils.plot_error_hidden_nodes(
train_MSE,
legend_names=legend_names,
hidden_nodes=nodes,
title='MLP with learning rate {0}, iterations {1} '.format(
learning_rate, num_iterations),
loss=val_MSE)
def __init__(self,
nfeat,
nhid,
nlayer,
nclasses,
mlpPos,
loss="kl",
useDropout=False,
keepProb=0.5,
useBatchNorm=False,
layerNorm=False,
detach=False):
super(GIN_pyg, self).__init__()
self.nlayer = nlayer
self.mlpPos = mlpPos
self.useDropout = useDropout
self.keepProb = keepProb
self.useBatchNorm = useBatchNorm
self.loss = loss
self.layerNorm = layerNorm
self.detach = detach
self.GinMlps = nn.ModuleList()
self.bns = nn.ModuleList()
# self.rnns = nn.ModuleList()
for i in range(nlayer):
self.GinMlps.append(
MLP([nhid, nhid, nhid], useDropout, keepProb, useBatchNorm))
if self.useBatchNorm == True:
self.bns.append(nn.BatchNorm1d(nhid))
# self.rnns.append(torch.nn.GRUCell(nhid, nhid, bias=True))
self.mlp1 = MLP([nfeat, nhid], useDropout, keepProb, useBatchNorm)
if self.useBatchNorm == True:
self.bn1 = nn.BatchNorm1d(nhid)
self.mlps = nn.ModuleList()
for i in range(len(mlpPos)):
self.mlps.append(
MLP([nhid, nhid, nclasses[i]], useDropout, keepProb,
useBatchNorm))
def __init__(self,
enc_past_size,
enc_dest_size,
enc_latent_size,
dec_size,
predictor_size,
fdim,
zdim,
sigma,
past_length,
future_length,
verbose):
'''
Args:
size parameters: Dimension sizes
sigma: Standard deviation used for sampling N(0, sigma)
past_length: Length of past history (number of timesteps)
future_length: Length of future trajectory to be predicted
'''
super(PECNet, self).__init__()
self.zdim = zdim
self.sigma = sigma
# takes in the past
self.encoder_past = MLP(input_dim = past_length*2, output_dim = fdim, hidden_size=enc_past_size)
self.encoder_dest = MLP(input_dim = 2, output_dim = fdim, hidden_size=enc_dest_size)
self.encoder_latent = MLP(input_dim = 2*fdim, output_dim = 2*zdim, hidden_size=enc_latent_size)
self.decoder = MLP(input_dim = fdim + zdim, output_dim = 2, hidden_size=dec_size)
self.predictor = MLP(input_dim = 2*fdim, output_dim = 2*(future_length-1), hidden_size=predictor_size)
architecture = lambda net: [l.in_features for l in net.layers] + [net.layers[-1].out_features]
if verbose:
print("Past Encoder architecture : {}".format(architecture(self.encoder_past)))
print("Dest Encoder architecture : {}".format(architecture(self.encoder_dest)))
print("Latent Encoder architecture : {}".format(architecture(self.encoder_latent)))
print("Decoder architecture : {}".format(architecture(self.decoder)))
print("Predictor architecture : {}".format(architecture(self.predictor)))
def __init__(self, episode_size=150):
self.model = MLP((SCREEN_HEIGHT_g, SCREEN_WIDTH_g), 300)
#self.load("models/model_1185.npz")
self.activations = []
self.frames = []
self.states_alive = []
self.episode_size = episode_size
self.episode_decisions = np.zeros((8))
self.episodes_wins = 0
self.episodes_nb = 0
self.iter = 0
