def __init__(self, args):
self.args = args
comm = MPI.COMM_WORLD
self.comm = comm
self.n_workers = comm.size
self.rank = comm.rank
if args.clean:
self.clean_model_dir()
env = gym.make(args.env_name)
if args.monitor and self.rank == 0:
env = gym.wrappers.Monitor(env, args.env_name + '_monitor', force=True)
self.env = env
self.n_ptbs = self.n_workers
self.p = eslib.Perturbation()
n_actions = env.action_space.n
self.model = mlp.MLP(n_actions)
optimizer = O.Adam(alpha=1e-2)
optimizer.setup(self.model)
optimizer.add_hook(GradientClipping(1e2))
optimizer.add_hook(WeightDecay(0.0005))
self.optimizer = optimizer
eslib.fix_model(self.model, gym.make(args.env_name).reset())
def train_learner_opt(self, X, Y, X_test, Y_test, learner_params=[]):
""" """
# self.logging.info('Standardizing data!')
# Y_test = np.array(Y_test)
# scaler = StandardScaler()
# X = scaler.fit_transform(X)
# X_test = scaler.transform(X_test)
# self.logging.info('X size is: %s and Y size is: %s and X_test size is: %s and Y_test size is: %s',
# '_'.join(map(str,X.shape)), str(len(Y)), '_'.join(map(str,X_test.shape)), str(len(Y_test)))
X, Y, X_test, Y_test = self.scale_all_data(X, Y, X_test, Y_test)
if self.method == 'classification':
clf = mlp.MLP(learner_params['l_rate'], learner_params['l1'],
learner_params['l2'], learner_params['n_hidden'],
learner_params['best_score'])
self.logging.info('optimal MLP classifier trained')
elif self.method == 'regression':
pass
# clf = self.learner()
# self.logging.info('optimal linear regressor trained with alpha = %s!', str(learner_params['C']))
clf.fit((X, X_test), (np.array(Y), np.array(Y_test)))
self.fit_opt_learner(X, Y, X_test, Y_test, clf)
def classify(fig):
# Standard MNIST format is 28x28 pixels and grayscale.
height, width, depth = 28, 28, 1
# Proccess image (c.f. fig_to_misc.py) and convert to numpy array
X = mnist_treat(fig)
X_array = np.array(X)
# Flatten image
X_flat = X_array.reshape(1, height * width)
# Normalize to 1 = white.
X_flat = X_flat.astype('float32')
X_flat /= 255
net = mlp.MLP()
# load latest model
path = os.path.join(os.curdir, 'models/*')
files = sorted(glob.iglob(path), key=os.path.getctime, reverse=True)
net.load(files[0])
# Run prediction
prediction = net.predict(X_flat)
return prediction[0]
def test_mlp(args):
"""Tests MLP."""
torch.set_default_dtype(torch.double)
X_train = np.loadtxt(f'{args.Output_path}X_train.csv', delimiter=',')
X_test_ID = np.loadtxt(f'{args.Output_path}X_test_ID.csv', delimiter=',')
X_test_OOD = np.loadtxt(f'{args.Output_path}X_test_OOD.csv', delimiter=',')
notear_model = torch.load(f'{args.Output_path}notear.pt')
model, ISL_id_train_mse, ISL_id_test_mse = mlp(X_train[:, 1:args.num_xy],
X_train[:, 0],
X_test_ID[:, 1:args.num_xy],
X_test_ID[:, 0],
epoches=200)
# model_OOD, ISL_ood_train_mse, ISL_ood_test_mse = mlp(
# X_train[:,1:args.num_xy], X_train[:,0], X_test_OOD[:, 1:args.num_xy],
# X_test_OOD[:,0], epoches=200)
torch.save(model.state_dict(), f'{args.Output_path}_induced_mlp.pt')
model = MLP.MLP(n_feature=args.num_xy - 1,
n_hidden=100,
n_output=1,
activation='Sigmoid')
model.load_state_dict(torch.load(f'{args.Output_path}_induced_mlp.pt'))
for data in [X_test_ID, X_test_OOD]:
ISL_pred = model(torch.tensor(data[:, 1:args.num_xy]))
notear_model.eval()
notear_pred = notear_model(torch.tensor(data))
ISL_mse = mean_squared_loss(data.shape[0], data[:, 0],
np.array(ISL_pred.detach().cpu())[:, 0])
notear_mse = mean_squared_loss(
data.shape[0], data[:, 0],
np.array(notear_pred.detach().cpu())[:, 0])
print(f'_ISL_pred', ISL_mse)
print(f'_notear_pred_train', notear_mse)
def main():
parser = argparse.ArgumentParser(description='okaeri kanojo trainer')
args = get_args(parser)
model = L.Classifier(mlp.MLP(N_IN, args.unit, N_OUT))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# Load the sprecog dataset
train_data = dataset.TrainingDataset(TRAIN_FILE)
train = train_data.convert_to_dataset()
test = train
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
# Save the model
chainer.serializers.save_npz(MODEL_FILE, model)
def main():
n_nodes = int(input('Enter the number of nodes: '))
model = mlp.MLP(n_nodes)
optimizer = optimizers.Adam()
optimizer.setup(model)
modes = ['Calculation', 'Learning', 'Exit']
while True:
draw_modes()
select = int(input('Enter the number of mode: '))
selected_mode = modes[select-1]
if (selected_mode == 'Exit'):
sys.exit()
if (selected_mode == 'Calculation'):
calc(model)
if (selected_mode == 'Learning'):
epoch = int(input('Enter the number of epoch: '))
digit = input('Enter the number of learning digit: ')
for _ in range(epoch):
a = np.random.rand(2).reshape(1, 2).astype(np.float32) * eval('1e+' + digit)
x = chainer.Variable(a)
x = model(x)
t = chainer.Variable(a.sum().reshape(1, 1))
model.zerograds()
loss = F.squared_error(x, t)
loss.backward()
optimizer.update()
print('loss: ' + str(loss))
def __init__(self, inSize, outSize):
super().__init__()
attn = attentionEncoder.AttentionEncoder(inputSize=inSize,
outputSize=1024,
attentionHidSize=512,
attentionRowSize=3)
mlp = M.MLP([1024, 256, 512, outSize], 'tanh', noActFinal=True)
self.add_link('attn', attn)
self.add_link('mlp', mlp)
def main():
training_data, validation_data, test_data = mnist.load()
net = mlp.MLP([784, 36, 10])
epochs = 500
mini_batch_size = 10
learning_rate = 0.5
lmbda = 5.0
drop_prob = 0.5
net.sgd(training_data, epochs, mini_batch_size, test_data, learning_rate,
lmbda, drop_prob)
def train_learner_cv(self, X, Y, optimal=False):
""" """
self.logging.info('Standardizing data!')
assert self.result_path != ''
X = np.asarray(X, dtype=np.float32, order='F')
Y = np.asarray(Y, dtype=np.short, order='F')
scaler = StandardScaler()
X = scaler.fit_transform(X)
self.logging.info('X size is: %s and Y size is: %s',
'_'.join(map(str, X.shape)), map(str, Y.shape))
for i in range(self.config.configuration["number_of_cvs"]):
self.logging.info('iteration number %s for cross validation',
str(i))
X_new, Y_new = shuffle(X, Y, random_state=i)
cv = StratifiedKFold(
y=Y_new,
n_folds=self.config.configuration["number_of_cv_folds"])
for param_ind in range(len(self.scores)):
print self.param_grid[param_ind]
accs = np.zeros(
self.config.configuration["number_of_cv_folds"])
fold_number = 0
l_rate = self.param_grid[param_ind][0]
l1 = self.param_grid[param_ind][1]
l2 = self.param_grid[param_ind][2]
n_hidden = self.param_grid[param_ind][3]
self.learner = mlp.MLP(l_rate, l1, l2, n_hidden)
for train_index, test_index in cv:
# print("TRAIN:", train_index, "TEST:", test_index)
X_train, X_test = X_new[train_index], X_new[test_index]
y_train, y_test = Y_new[train_index], Y_new[test_index]
datasets = [X_train, y_train, X_test, y_test]
accs[fold_number] = self.learner.fit((X_train, X_test),
(y_train, y_test))
# accs[fold_number] = mlp.apply_mlp(l_rate, l1, l2, n_hidden, datasets)
fold_number += 1
self.scores[param_ind, i] = np.mean(accs)
min_ind = np.argmin(np.mean(self.scores, axis=1))
self.logging.info('Writing the results to file!')
with open(self.result_path, 'w') as res_file:
print >> res_file, np.mean(self.scores)
print >> res_file, dict(l_rate=self.param_grid[min_ind][0],
l1=self.param_grid[min_ind][1],
l2=self.param_grid[min_ind][2],
n_hidden=self.param_grid[min_ind][3])
print >> res_file, np.std(self.scores, axis=1)
def main():
words = 900
training_data, validation_data, test_data = reuters.load(words)
net = mlp.MLP([words, 80, 46])
epochs = 200
mini_batch_size = 16
learning_rate = 0.5
lmbda = 1.0
drop_prob = 0.5
net.sgd(training_data, epochs, mini_batch_size, test_data, learning_rate,
lmbda, drop_prob)
def set_params_dict(self, learner_params):
if self.method == 'classification':
self.learner = mlp.MLP(learner_params['learning_rate'],
learner_params['l1'], learner_params['l2'],
learner_params['n_hidden'],
learner_params['best_error'])
elif self.method == 'regression':
sys.exit('Error! regression not implemented yet!!!!!')
def set_params_list(self, learner_params, i):
learning_rate = learner_params[0]
l1 = learner_params[1]
l2 = learner_params[2]
n_hidden = learner_params[3]
if self.method == 'classification':
self.learner = mlp.MLP(learning_rate, l1, l2, n_hidden)
elif self.method == 'regression':
sys.exit('Error! regression not implemented yet!!!!!')
def run_mlp(bounds):
_mlp = mlp.MLP(dense1=bounds[0],
dense2=bounds[1],
drop1=bounds[2],
drop2=bounds[3],
batch_size=bounds[4],
activation=bounds[5],
opt=bounds[6])
mnist_evaluation = _mlp.mlp_evaluate()
print(mnist_evaluation)
return mnist_evaluation[0],
def mlp(X_train,
Y_train,
X_test,
Y_test,
epoches=100,
hidden=100,
lr=0.01,
batch_size=64):
"""MLP training."""
input_feature_dim = X_train.shape[1]
output_feature_dim = 1
x_train = torch.tensor(X_train)
y_train = torch.tensor(Y_train)
x_test = torch.tensor(X_test)
y_test = torch.tensor(Y_test)
train_dataset = MLP.CustomDataset(torch.tensor(X_train),
torch.tensor(Y_train))
test_dataset = MLP.CustomDataset(torch.tensor(X_test),
torch.tensor(Y_test))
test_loader = DataLoader(test_dataset, batch_size=batch_size)
train_loader = DataLoader(train_dataset, batch_size=batch_size)
model = MLP.MLP(n_feature=input_feature_dim,
n_hidden=hidden,
n_output=output_feature_dim,
activation='Sigmoid')
optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5)
loss_func = torch.nn.MSELoss()
for epoch in range(1, epoches):
loss = MLP.train(model, epoch, train_dataset, train_loader, optimizer,
loss_func)
train_loss = MLP.test(model, train_loader, loss_func)
test_loss = MLP.test(model, test_loader, loss_func)
if epoch % 10 == 0:
print(
'Epoch: {:03d}, Loss: {:.5f}, train_loss: {:.5f}, test_loss: {:.5f}'
.format(epoch, loss, train_loss, test_loss))
model.eval()
output = model(x_test)
mse = mean_squared_loss(x_test.shape[0], np.array(y_test.detach()),
np.array(output[:, 0].detach()))
train_output = model(x_train)
train_mse = mean_squared_loss(x_train.shape[0], np.array(y_train.detach()),
np.array(train_output[:, 0].detach()))
print(mse)
return model, train_mse, mse
def __init__(self, n_objects, in_features, unary, binary, terminal,
nonlinear, triu):
super(RN, self).__init__()
self.n_objects = n_objects
self.in_features = in_features
if unary:
assert unary[0] == in_features
assert unary[-1] * 2 == binary[0]
else:
assert binary[0] == in_features * 2
assert binary[-1] == terminal[0]
self.unary = mlp.MLP(unary, nonlinear) if unary else None
self.binary = mlp.MLP(binary, nonlinear)
self.terminal = mlp.MLP(terminal, nonlinear)
self.nonlinear = nonlinear
if triu:
self.mask = th.triu(th.ones(self.n_objects, self.n_objects), 1)
self.mask = self.mask.view(1, self.n_objects * self.n_objects, 1)
else:
self.mask = None
def logic_test():
or_perceptron = mlp.MLP(2, alpha=0.9, eta=0.01)
or_perceptron.add_layer(2)
or_perceptron.add_layer(2)
or_perceptron.add_layer(1)
and_perceptron = mlp.MLP(2, alpha=0.9, eta=0.01)
and_perceptron.add_layer(2)
and_perceptron.add_layer(1)
xor_perceptron = mlp.MLP(2, alpha=0.9, eta=0.05)
xor_perceptron.add_layer(2)
xor_perceptron.add_layer(2)
xor_perceptron.add_layer(1)
# X = np.array([ np.random.randint(0, 2, 2) for i in range(0,10) ])
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
T_or = np.reshape(np.array([(x[0] | x[1]) for x in X]), (-1, 1))
T_and = np.reshape(np.array([(x[0] & x[1]) for x in X]), (-1, 1))
T_xor = np.reshape(np.array([(x[0] ^ x[1]) for x in X]), (-1, 1))
or_iterations = or_perceptron.train(X, T_or)
xor_iterations = xor_perceptron.train(X, T_xor)
and_perceptron.train(X, T_and)
o_or = or_perceptron.recall(X)
o_xor = xor_perceptron.recall(X)
o_and = and_perceptron.recall(X)
print "Or (" + str(or_iterations) + " iterations)"
print T_or
print o_or
print "Xor (" + str(xor_iterations) + " iterations)"
print T_xor
print o_xor
def load_weights(self, weights, x, y, index):
self.members = []
self.weights = []
raise "needs fixing"
for w in weights:
rng = numpy.random.RandomState(self.params.random_seed)
m = mlp.MLP(params=self.params,
rng=rng,
input=x,
index=index,
x=x,
y=y)
m.set_weights(w)
self.members.append(m)
return self.members
def gauss_test():
# Plots
P_train = np.array([(12 * np.random.rand(1, 2)[0] - 6)
for i in range(0, 200)])
P_train = np.transpose(P_train)
X_train = P_train[0]
Y_train = P_train[1]
Z_train = np.reshape(np.exp(-(X_train**2 + Y_train**2) / 10), (-1, 1))
p = mlp.MLP(2, alpha=0.9, eta=0.01, activation="sigmoid")
p.add_layer(8)
p.add_layer(4)
p.add_layer(1)
P_train = np.transpose(P_train)
iterations = p.train(P_train, Z_train)
print "iterations: " + str(iterations)
P_test = np.array([(12 * np.random.rand(1, 2)[0] - 6)
for i in range(0, 200)])
P_test = np.transpose(P_test)
X_test = P_test[0]
Y_test = P_test[1]
# Z_test = np.exp(-(X_test ** 2+ Y_test **2)/10) - 0.5
P_test = np.transpose(P_test)
Z_recall = p.recall(P_test)
GRID_POINTS = 100
# Surface grid
g = np.linspace(-6, 6, GRID_POINTS)
G_X = np.array([g for i in range(0, GRID_POINTS)])
G_Y = np.array([i * np.ones(GRID_POINTS) for i in g])
G_Z = np.exp(-(G_Y**2 + G_X**2) / 10)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# Plot a basic wireframe.
ax.plot_wireframe(G_X, G_Y, G_Z, rstride=5, cstride=5, color="#bbaaaa")
ax.scatter(X_test, Y_test, Z_recall, color="#00ff00")
plt.show()
def MLP(k, df, num_perceptrons_in_layer, max_iteration, error_threshold, learning_rate, batch_size):
num_data_per_fold = round(len(df.index) / k)
models = []
models_accuracy = []
# Creating models and counting accuracy
for i in range(k):
first_idx_val = i * num_data_per_fold
last_idx_val = (i+1) * num_data_per_fold - 1
if (first_idx_val != 0 and last_idx_val != (len(df.index) - 1)):
df_training_top = df.iloc[:first_idx_val, :].reset_index(drop = True)
df_training_bottom = df.iloc[(last_idx_val + 1):, :].reset_index(drop = True)
df_training = pandas.concat([df_training_top, df_training_bottom])
elif (first_idx_val == 0 and last_idx_val != (len(df.index) - 1)):
df_training = df.iloc[(last_idx_val + 1):, :].reset_index(drop = True)
elif (first_idx_val != 0 and last_idx_val == (len(df.index) - 1)):
df_training = df.iloc[:first_idx_val, :].reset_index(drop = True)
else:
df_training = pandas.DataFrame()
df_validation = df.iloc[first_idx_val:last_idx_val, :].reset_index(drop = True)
print("-------------------- MODEL", i+1, "--------------------")
result_model = mlp.MLP(df_training, num_perceptrons_in_layer, max_iteration, error_threshold, learning_rate, batch_size)
models.append(result_model)
result_accuracy = mlp.count_accuracy(result_model, df_validation)
models_accuracy.append(result_accuracy)
# Printing each model and its accuracy
models[i].print_model()
print("ACCURACY:", models_accuracy[i])
print("")
best_model_idx = 0
best_accuracy = models_accuracy[0]
for i in range(k):
if (models_accuracy[i] > best_accuracy):
best_model_idx = i
best_accuracy = models_accuracy[i]
return models[best_model_idx]
def counter_exp(args):
"""Experiments with a counter."""
torch.set_default_dtype(torch.double)
X_train = np.loadtxt(f'{args.Output_path}X_train.csv', delimiter=',')
X_test_ID = np.loadtxt(f'{args.Output_path}X_test_ID.csv', delimiter=',')
X_test_OOD = np.loadtxt(f'{args.Output_path}X_test_OOD.csv', delimiter=',')
model_ID = MLP.MLP(n_feature=2,
n_hidden=100,
n_output=1,
activation='Sigmoid')
model_ID.load_state_dict(torch.load(f'{args.Output_path}_induced_mlp.pt'))
notear_model = torch.load(f'{args.Output_path}notear.pt')
counter = dict()
model_ID.eval()
data = X_train.copy()
for counter_index in range(1, args.num_xy + args.num_s, 1):
# counterfactual on trainining data
data[:, counter_index] = np.random.normal(loc=5,
scale=10,
size=data.shape[0])
# make prediction on the modified data
data[:, 0] = sigmoid(np.sum(data[:, 1:args.num_xy], axis=1))
ISL_pred = model_ID(torch.tensor(data[:, 1:args.num_xy]))
notear_model.eval()
notear_pred = notear_model(torch.tensor(data))
ISL_mse = mean_squared_loss(data.shape[0], data[:, 0],
np.array(ISL_pred.detach().cpu())[:, 0])
notear_mse = mean_squared_loss(
data.shape[0], data[:, 0],
np.array(notear_pred.detach().cpu())[:, 0])
print(f'counteron{counter_index}_ISL_pred', ISL_mse)
print(f'counteron{counter_index}notear_pred_train', notear_mse)
counter[f'counteron{counter_index}_ISL_pred'] = ISL_mse
counter[f'counteron{counter_index}notear_pred_train'] = notear_mse
with open(f'{args.Output_path}counter_u=5s=0_mse.json', 'w+') as f:
json.dump(metrics, f, indent=4)
def mlpMethod(candidateSet, k):
mlp_model = mlp.MLP(isReadModel=True, isRun=True)
mlp_model.train_model(emb=200, epoch=20)
candidateSet = [list(i) for i in candidateSet]
area = candidateSet[0][0]
context = "computer_science"
candidate = []
for d in range(len(candidateSet) - 1):
tmpcats = candidateSet[d + 1]
for c in tmpcats:
candidate.append(c)
candidate = list(set(candidate))
scores = mlp_model.predict(area, candidate, context)
ranked_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
#print(ranked_scores)
ranked_scores = ranked_scores[:k]
return ranked_scores
def select_ai(cl, data, targets, original_import):
""" Select an AI. Create in instance of the needed class and return it. """
ai = None
# MLP
if cl == "MLP":
ai = mlp.MLP(data,
targets,
hidden_nodes=MLP_HIDDEN_NODES,
beta=MLP_BETA,
momentum=MLP_MOMENTUM)
print "MLP created."
# RBF
elif cl == "RBF":
# Adjust target format for RBF: [win, draw, loss]
targets_rbf = ny.zeros((len(targets), 3))
for i in range(len(targets)):
win = 1 if targets[i] == WIN else 0
draw = 1 if targets[i] == DRAW else 0
loss = 1 if targets[i] == LOSS else 0
targets_rbf[i] = [win, draw, loss]
ai = rbf.RBF(data,
targets_rbf,
sigma=RBF_SIGMA,
rbfs_amount=RBF_NODES,
use_kmeans=RBF_KMEANS,
normalize=RBF_NORMALIZE)
print "RBF created."
# DTree
elif cl == "DTree":
data = []
for value in original_import:
zipped = zip(DATA_ATTRIBUTES, [datum for datum in value])
data.append(dict(zipped))
ai = dtree.DTree(data, DATA_ATTRIBUTES, DT_TARGET_ATTRIBUTE)
print "DTree created."
return ai
def __init__(self, config):
""" Initialize default values """
#self.config = config
# initialize the sbpca subsystem
self.sbpca = sbpca.SbPca(config)
# initialize the mlp subsytem
self.net = mlp.MLP(config['wgt_file'], config['norms_file'])
# parameters specific to SAcC part
self.ptchtab = np.r_[0, np.loadtxt(config['pcf_file'])]
self.hmm_vp = config['hmm_vp']
self.n_s = 10.0
self.start_utt = 0
self.write_rownum = False
self.write_time = False
self.write_sbac = False
self.write_sbpca = False
self.write_posteriors = False
self.write_pitch = True
self.write_pvx = True
self.dither_level = 1e-3
if 'n_s' in config:
self.n_s = config['n_s']
if 'start_utt' in config:
self.start_utt = config['start_utt']
if 'write_rownum' in config:
self.write_rownum = config['write_rownum']
if 'write_time' in config:
self.write_time = config['write_time']
if 'write_sbac' in config:
self.write_sbac = config['write_sbac']
if 'write_sbpca' in config:
self.write_sbpca = config['write_sbpca']
if 'write_posteriors' in config:
self.write_posteriors = config['write_posteriors']
if 'write_pitch' in config:
self.write_pitch = config['write_pitch']
if 'write_pvx' in config:
self.write_pvx = config['write_pvx']
# added 2014-04-10
if 'dither_level' in config:
self.dither_level = config['dither_level']
def train(data, args):
X_train, Y_train, X_dev, Y_dev, X_test, Y_test, U_train, U_dev, U_test, classLatMedian, classLonMedian, userLocation = data
if args.model == 'mlp':
classifier = mlp.MLP(n_epochs=args.epochs,
batch_size=args.batch,
complete_prob=False,
add_hidden=True,
regul_coef=args.reg,
save_results=False,
hidden_layer_size=args.hid,
drop_out_coef=args.drop,
early_stopping_max_down=5)
classifier.fit(X_train, Y_train, X_dev, Y_dev)
y_pred_dev = classifier.f_predict(X_dev)
y_pred_test = classifier.f_predict(X_test)
elif args.model == 'lr':
classifier = SGDClassifier(loss='log',
penalty='elasticnet',
alpha=args.reg,
n_iter=5,
l1_ratio=0.9,
n_jobs=5,
random_state=77)
classifier.fit(X_train, Y_train)
y_pred_dev = classifier.predict(X_dev)
y_pred_test = classifier.predict(X_test)
else:
logging.info(
'model should be either lr or mlp, current model is {}'.format(
args.model))
logging.info('dev results')
mean, median, acc_at_161 = geo_eval(Y_dev, y_pred_dev, U_dev,
classLatMedian, classLonMedian,
userLocation)
logging.info('test results')
mean, median, acc_at_161 = geo_eval(Y_test, y_pred_test, U_test,
classLatMedian, classLonMedian,
userLocation)
def MLP(df, num_perceptrons_in_layer, max_iteration, error_threshold,
learning_rate, batch_size):
# memisahkan data training dan testing dengan perbandingan 9:1
separator_iris = round((9 / 10) * len(df.index))
train_iris = df.iloc[:separator_iris, :].reset_index(drop=True)
test_iris = df.iloc[separator_iris:, :].reset_index(drop=True)
# pembelajaran dengan training data
result_model = mlp.MLP(train_iris, num_perceptrons_in_layer, max_iteration,
error_threshold, learning_rate, batch_size)
# menghitung kinerja
result_accuracy = mlp.count_accuracy(result_model, test_iris)
# menampilkan tree hasil
result_model.print_model()
print('Akurasi :')
print(result_accuracy)
print('Confussion Matrix untuk Virginica, Versicolor, Setosa :')
print(ConfusionMatrixMLP(result_model, test_iris))
return result_model
def train_model(train_file, hidden_neurons, mode, eta, threshold, saved_model):
dataset = np.loadtxt(train_file, delimiter=',', skiprows=1)
print('loaded training file!')
sys.stdout.flush()
X = np.round(dataset[:, 1:len(dataset[0])] / 255)
Y = dataset[:, 0]
Y = np.array([Number.from_number(int(y)).array for y in Y])
if mode == 'recover' and os.path.isfile(saved_model):
model = pickle.load(open(saved_model, 'rb'))
else:
model = mlp.MLP(input_layer_neurons=X.shape[1],
hidden_layer_neurons=hidden_neurons,
output_layer_neurons=10)
if not os.path.isdir('trained'):
os.mkdir('trained')
print('training network with', hidden_neurons, 'hidden neurons:')
sys.stdout.flush()
model.learn(X, Y, eta, threshold, saved_model)
if (mode != 'predict'):
print('trained!')
sys.stdout.flush()
def expt_001():
train = load_sonar('data/sonar.train')
dev = load_sonar('data/sonar.dev')
test = load_sonar('data/sonar.test')
gamma = 1 # the learning rate
epochs = 100 # the maximum number of epochs
layers = [12] # one hidden layer with one hidden unit
din = len(train[0][0])
dout = len(train[0][1])
m = mlp.MLP(layers, din, dout)
lossfn = loss.sum_squares
savefreq = 0 # store the model every savefreq steps
logfreq = 1 # print updates every logfreq steps
step = 0
tsum = 0
tbegin = time()
for epoch in range(epochs):
if ((epoch % logfreq) == 0):
tloss = time()
lss_train = m.loss(train, loss.zeroone)
lss_dev = m.loss(dev, loss.zeroone)
tloss = time() - tloss
counter, tacc, dacc = epoch + 1, 1 - lss_train, 1 - lss_dev
records[counter] = records.get(counter, {})
records[counter]["train"] = records[counter].get("train",
[]) + [tacc]
records[counter]["dev"] = records[counter].get("dev", []) + [dacc]
print('Accuracy after %d rounds is %f train, %f dev ' %
(epoch, tacc, dacc))
m.gd_step(train, lossfn, gamma=gamma)
def main():
mlp = MLP.MLP(sizeX * sizeY, bottleneck, sizeX * sizeY)
if (path_weights != ""):
mlp.load(path_weights)
print("Weights init from {}".format(path_weights))
dataset = Dataset.Dataset((sizeX, sizeY))
# dataset.build("../dataset/matthieu2.txt", from_vid="../dataset/full-07_11_2019-001.avi")
# dataset.build("../dataset/mb.txt", from_vid="../dataset/bout.avi")
# dataset.build("../dataset/mbl.txt", from_vid="../dataset/louis.avi")
# dataset.build("../dataset/mblr.txt", from_vid="../dataset/remi.avi")
dataset.load(path_to_dataset)
x_train, y_train, x_test, y_test, x_valid, y_valid = dataset.split_and_process(
delta_time, test_ratio, valid_ratio)
err = learnDataset(mlp, x_train, y_train, x_valid, y_valid, nb_epochs)
datasetTest = Dataset.Dataset((sizeX, sizeY))
datasetTest.load("../dataset/test.txt")
x, y = datasetTest.process(5)
test_activity(mlp, x, y)
save_session_parameters()
def encode(eta, hidden, inputs, epochs):
#Generate inputs
X = gen_inputs(inputs)
#Create the MLP
MLP = mlp.MLP(eta, 1, hidden)
#Initialize the MLP
MLP.learn(X, X)
#Stop condition
not_converged = 1
#counter until convergence
i = 0
while (not_converged):
#Continue learning
MLP.continue_learning(epochs)
error = np.matrix.round(MLP.predict(X, X) - X)
if (np.all(error == 0)):
not_converged = 0
i += epochs
return MLP, i
def train_algo(params):
"""
Fetch the total data to train the model on
"""
dataset = data.DataReader(params['data']['type'])
if params['data']['type'] == 'sql':
dataset.fetch_data(con=dbconfig.connections_[params['data']['source']](), query=params['data']['detail'])
elif params['data']['type'] == 'file':
dataset.fetch_data(file=params['data']['source'])
data_ = data.TrainingData(dataset, target='Put', data_split=params['data']['data_split'])
"""
Construct the MLP and optimizer arguments
"""
mlp_args = {'data':data_, **params['algo']}
"""
Define and train the network
"""
mdl = mlp.MLP(**mlp_args)
# train the network
train_history = mdl.sgd_train(**params['train'], optim_options=params['optim'])
# save the model
mdl.save(params['results']['model_path'])
# test the network
test_results = mdl.test()
# show results
mdl.test_scatter(test_results, save_fig= params['results']['test_scatter'])
mdl.plot_train_valid_curve(train_history, save_fig= params['results']['train_curve'])
