def predict_it(train_result, test_id, test_set):
nn, tr, train_time = result
predict_start = time.time()
prediction_result = nn.predict(test_set[0])
pred_time = time.time() - predict_start
report = NeuralNet.score_report(test_set[1], prediction_result.predicted)
print(
"[{id}][{train_time:3.1f}/{pred_time:3.1f}]:{nn}:\n{report}\n".format(
id=test_id,
train_time=train_time,
pred_time=pred_time,
nn=nn,
report=NeuralNet.format_score(report)))
return prediction_result, report, pred_time
def _start_job(self, job_id):
job = self.job_list[job_id]
job.create_neuralnet()
job.status = 'training:started'
job.neuralnet.train(
lambda neuralnet, train_data: self._train_callback(job, train_data))
job.status = 'prediction:started'
for test_set_id, test_set in job.test_sets.items():
test_set_x, test_set_y = test_set
prediction_result = job.neuralnet.predict(test_set_x)
score = NeuralNet.score_report(
test_set_y, prediction_result.predicted)
self.add_to_prediction_log(job, test_set_id, score)
# print("{0}:\n{1}\n".format(
# job.neuralnet, NeuralNet.format_score_report(score)))
job.status = 'completed'
return job
import numpy as np
import pandas as pd
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
df = pd.read_csv("./data/ex2data1.csv")
train_set, dev_set, test_set = NeuralNet.split(df.values, 0.8, 0.1, 0.1)
train_x, train_y = train_set[:, 0:-1], train_set[:, -1]
dev_x, dev_y = dev_set[:, 0:-1], dev_set[:, -1]
test_x, test_y = test_set[:, 0:-1], test_set[:, -1]
nn = NeuralNet(train_x, train_y, hidden_layers=(2, 2), iteration_count=6000)
train_result = nn.train(lambda nn, iter: print("{0:.2f}".format(iter.cost))
if iter.total_iteration_index % 100 == 0 else None)
result = nn.predict(test_x, expected=test_y)
print("{0}:\n{1}\n".format(nn, NeuralNet.format_score(result.score)))
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
from multiprocessing import Process
# from matplotlib.pyplot import plot, show
from mnist import get_datasets
from sklearn.metrics import confusion_matrix, accuracy_score
from sklearn import datasets, svm, metrics
from sklearn.neural_network import MLPClassifier
df = pd.read_csv("./data/winequality-red.csv", sep=";")
train_set, dev_set, test_set = NeuralNet.split(df.values, 0.8, 0.1, 0.1)
train_x, train_y = train_set[:, 0:-1], train_set[:, -1]
dev_x, dev_y = dev_set[:, 0:-1], dev_set[:, -1]
test_x, test_y = test_set[:, 0:-1], test_set[:, -1]
costs = {}
def train_cb(cost, epoch, current_batch_index, total_batch_index, iteration):
if (iteration % 10 == 0):
# print("{epoch:<4} {current_batch:<6} {iteration:<6} {cost:8.4f}".format(
# epoch=epoch,
# current_batch=current_batch_index,
# cost=cost, iteration=iteration))
if (costs.get(epoch) == None):
valid_x = valid_set[0]
valid_y = valid_set[1]
return (train_x, train_y), (test_x, test_y), (valid_x, valid_y)
(train_x, train_y), (test_x, test_y), (valid_x, valid_y) = get_datasets()
def train_callback(nn, it):
if (it.total_iteration_index % 10 == 0):
print("it:{it:>5}, cost:{cost:6.2f}".format(
it=it.total_iteration_index, cost=it.cost))
nn = NeuralNetWithAdam(train_x,
train_y,
hidden_layers=(15, ),
iteration_count=200,
learning_rate=0.01,
minibatch_size=0,
epochs=1)
print("Training ...")
train_result = nn.train(train_callback)
prediction_result = nn.predict(test_x)
report = NeuralNet.score_report(test_y, prediction_result.predicted)
print("{0}:\n{1}\n".format(nn, NeuralNet.format_score(report)))
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
from aibrite.ml.analyser import NeuralNetAnalyser
from aibrite.ml.loggers import CsvLogger
df = pd.read_csv("./data/winequality-red.csv", sep=";")
np.random.seed(5)
data = df.values
train_set, test_set, dev_set = NeuralNet.split(data,
0.6,
0.20,
0.20,
shuffle=True)
train_x, train_y = (train_set[:, 0:-1]), train_set[:, -1]
dev_x, dev_y = (dev_set[:, 0:-1]), dev_set[:, -1]
test_x, test_y = (test_set[:, 0:-1]), test_set[:, -1]
labels = [3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
normalize_inputs = [True, False]
iteration_count = [50, 100, 150]
learning_rate = [0.005, 0.002]
hidden_layers = [(32, 64, 128), (4, 4)]
lambds = [0.4, 0.8, 0.9]
learnin_rate_decay = [0.]
def print_summary(self, target=None):
all_test_sets = self.test_set_names
if (len(all_test_sets) == 1):
target = all_test_sets[0]
elif target is None:
target = '__overall__'
best_by_target = self.model_results_sorted[target][-1]
worst_by_target = self.model_results_sorted[target][0]
self.generate_stats(best_by_target)
for mr in self.model_results:
self.print_job(mr)
print("-" * 80)
print("\n")
self.print_h1("Best Results")
title_format = "{test_set:<12}{f1:>10}{precision:>10}{recall:>10}{support:>10}{model:>12}"
title = title_format.format(
test_set="", precision="prec", recall="recall", f1="f1", support="support", time="time", model="model")
print(title)
for test_set, mr in self.best_models.items():
if (test_set == '__overall__'):
precision, recall, f1, support = mr.job_result.prediction_totals
else:
pred_result = mr.job_result.prediction_results[test_set]
precision, recall, f1, support = pred_result.score.totals
values_format = "{test_set:<12}{f1:10.2f}{precision:10.2f}{recall:10.2f}{support:>10}{model:>12}"
print(values_format.format(
test_set=test_set,
f1=f1,
precision=precision,
recall=recall,
support=support,
model=mr.job_result.id))
self.print_h1("Best Models")
single_hyper_parameter_models = list(filter(lambda mr: len(
mr.hyper_parameter_changes) == 1, self.model_results))
for mr in set(self.best_models.values()):
self.print_job(mr)
self.print_subtitle("hyper parameter tunings")
title = "{0:<16}{1:>10}{2:>10}".format(
"", "current", "new")
for k, v in mr.job_result.prediction_results.items():
title += "{0:>12}".format(k + " f1")
print(title)
print("-" * len(title))
for mrs in single_hyper_parameter_models:
# self.print_job(mrs)
change_on_hp = list(mrs.hyper_parameter_changes.values())[0]
if change_on_hp.isNumeric:
line = "{0:<16}{1:>10}{2:>10}".format(change_on_hp.name,
change_on_hp.new, change_on_hp.old)
else:
line = "{0:<16}{1:>10}{2:>10}".format(change_on_hp.name,
str(change_on_hp.new), str(change_on_hp.old))
used_combinations = {}
for pred_key, pred_change in mrs.prediction_changes.items():
test_set, best_test_set = pred_key
if (mr != self.best_models[best_test_set] or used_combinations.get(test_set, None) != None):
continue
used_combinations[test_set] = self.best_models[best_test_set]
line += "{0:>12}".format(pred_change.formated_percent())
print(line)
print("-" * len(line)
) if mrs != single_hyper_parameter_models[-1] else None
print("-" * 80)
print("\n")
if (target != '__overall__'):
print(
"Here is the score report for {0}".format(best_by_target.job_result.id))
score = best_by_target.job_result.prediction_results[target].score
print(NeuralNet.format_score(score))
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
from multiprocessing import Process
from matplotlib.pyplot import plot, show
from mnist import get_datasets
df = pd.read_csv("./data/winequality-red.csv", sep=";")
train_set, dev_set, test_set = NeuralNet.split(df.values, 0.8, 0.1, 0.1)
# train_x, train_y = train_set[:, 0:-1].T, train_set[:, -1:].T
# dev_x, dev_y = dev_set[:, 0:-1].T, dev_set[:, -1:].T
# test_x, test_y = test_set[:, 0:-1].T, test_set[:, -1:].T
(train_x, train_y), (test_x, test_y), (dev_x, dev_y) = get_datasets()
costs = {}
def train_cb(cost, epoch, current_batch_index, total_batch_index, iteration):
if (iteration % 10 == 0):
# print("{epoch:<4} {current_batch:<6} {iteration:<6} {cost:8.4f}".format(
# epoch=epoch,
# current_batch=current_batch_index,
import numpy as np
import pandas as pd
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
df = pd.read_csv("./data/ex2data1.csv")
train_set, dev_set, test_set = NeuralNet.split(df.values, 0.8, 0.1, 0.1)
train_x, train_y = train_set[:, 0:-1], train_set[:, -1]
dev_x, dev_y = dev_set[:, 0:-1], dev_set[:, -1]
test_x, test_y = test_set[:, 0:-1], test_set[:, -1]
nn = NeuralNet(train_x, train_y, hidden_layers=(2, 2), iteration_count=6000)
train_result = nn.train()
prediction_result = nn.predict(test_x)
report = NeuralNet.score_report(test_y, prediction_result.predicted)
print("{0}:\n{1}\n".format(nn, NeuralNet.format_score(report)))
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
df = pd.read_csv("./data/winequality-red.csv", sep=";")
# df = df[df['quality'] != 8.0]
# df = df[df['quality'] != 3.0]
# print(df.values.shape)
# np.random.seed(1)
data = df.values
# data = NeuralNet.shuffle(data)
train_set, dev_set, test_set = NeuralNet.split(data, 0.6, 0.2, 0.2)
train_x, train_y = train_set[:, 0:-1], train_set[:, -1]
train_x, train_y = NeuralNet.zscore(train_set[:, 0:-1]), train_set[:, -1]
dev_x, dev_y = NeuralNet.zscore(dev_set[:, 0:-1]), dev_set[:, -1]
test_x, test_y = NeuralNet.zscore(test_set[:, 0:-1]), test_set[:, -1]
labels = [3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
iterations = [2000]
learning_rates = [0.008]
hidden_layers = [(24, 36, 24, 12, 6)]
test_sets = {
'dev': (dev_x, dev_y),
'test': (test_x, test_y),
'train': (train_x, train_y)
import numpy as np
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
from aibrite.ml.analyser import NeuralNetAnalyser
df = pd.read_csv("./data/ex2data1.csv", sep=",")
# df = df[df['quality'] != 8.0]
# df = df[df['quality'] != 3.0]
np.random.seed(5)
data = df.values
data = NeuralNet.shuffle(data)
train_set, test_set, dev_set = NeuralNet.split(data, 0.7, 0.15, 0.15)
train_x, train_y = train_set[:, 0:-1], train_set[:, -1]
train_x, train_y = (train_set[:, 0:-1]), train_set[:, -1]
dev_x, dev_y = (dev_set[:, 0:-1]), dev_set[:, -1]
test_x, test_y = (test_set[:, 0:-1]), test_set[:, -1]
labels = [3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
iterations = [200]
learning_rates = [0.02]
hidden_layers = [(4, 6, 12)]
lambds = [0.8]
test_sets = {
import numpy as np
import pandas as pd
from aibrite.ml.neuralnet import NeuralNet
from aibrite.ml.neuralnetwithmomentum import NeuralNetWithMomentum
from aibrite.ml.neuralnetwithrmsprop import NeuralNetWithRMSprop
from aibrite.ml.neuralnetwithadam import NeuralNetWithAdam
df = pd.read_csv("./data/winequality-red.csv", sep=";")
train_set, dev_set, test_set = NeuralNet.split(df.values,
0.8,
0.1,
0.1,
shuffle=True)
train_x, train_y = train_set[:, 0:-1], train_set[:, -1]
dev_x, dev_y = dev_set[:, 0:-1], dev_set[:, -1]
test_x, test_y = test_set[:, 0:-1], test_set[:, -1]
nn = NeuralNetWithAdam(train_x,
train_y,
hidden_layers=(32, 64, 128, 64),
iteration_count=500,
learning_rate=0.005,
epochs=1,
shuffle=True,
normalize_inputs=True)
train_result = nn.train()