def testSaveAndLoad(self):
nn = neuralnet.NeuralNet(2, [2, 2], neuralnet.Sigmoid())
nn.layers[0][0].weights=[0.01, 0.02]
nn.layers[0][0].bias=0.03
nn.layers[0][1].weights=[0.04, 0.05]
nn.layers[0][1].bias=0.06
nn.layers[1][0].weights=[0.07, 0.08]
nn.layers[1][0].bias=0.09
nn.layers[1][1].weights=[0.10, 0.11]
nn.layers[1][1].bias=0.12
tmpfile = tempfile.mkstemp()[1]
nn.save(tmpfile)
nn2 = neuralnet.NeuralNet(1, [1, 1], neuralnet.ReLu())
nn2.load(tmpfile)
# This should give a more readable error when there are differences
self.assertEqual(nn.__str__(), nn2.__str__())
# This ensure the previous test didn't miss any important thing
self.assertEqual(nn2.activation.name(), nn.activation.name())
self.assertEqual(nn2.average_gradient, nn.average_gradient)
for i in range(0, 2):
for j in range(0, 2):
for k in range(0, 2):
self.assertAlmostEqual(nn.layers[i][j].weights[k], nn2.layers[i][j].weights[k])
self.assertAlmostEqual(nn.layers[i][j].bias, nn2.layers[i][j].bias)
def cross_over(self):
depth_a = self.father.get_network_depth()
depth_b = self.mother.get_network_depth()
if depth_a > depth_b:
warp_length = depth_a
else:
warp_length = depth_b
self.father.warp_layer_probablity(warp_length)
self.mother.warp_layer_probablity(warp_length)
layer_warp_a = self.father.get_warp_probability()
layer_warp_b = self.mother.get_warp_probability()
layer_output = (layer_warp_a + layer_warp_b) / 2
new_list_layers = []
for col_ind, layer_prob in enumerate(layer_output.T):
layer_prob_a = layer_warp_a[:, col_ind]
layer_prob_b = layer_warp_b[:, col_ind]
select_a = self.select_one_parent(layer_prob, layer_prob_a,
layer_prob_b)
if select_a == True:
layer = self.select_layer_from_parent(self.father, col_ind)
else:
layer = self.select_layer_from_parent(self.mother, col_ind)
new_list_layers.append(layer)
new_net = nn.NeuralNet(self.family_num, self.child_num)
new_net.set_list_layers(
new_list_layers, max(self.father.layer_num, self.mother.layer_num))
if not test:
c = combine(self.father, self.mother, new_net)
c.combine()
return new_net
def mutation_inter_layer(self, net):
if not test:
print('net ' + net.get_fnum_gen() + ' inter mutation')
mutated_net = nn.NeuralNet(self.family_num, self.child_num)
mutated_net.set_list_layers(net.get_list_layers(), net.layer_num)
mutated_net.adjust_layer_list_random()
return mutated_net
def train_network(filename):
params = load_params(filename)
limit = params['limit']
train_labels, train_images, train_examples = load_data(
TRAIN_LABELS, TRAIN_IMAGES, limit)
test_labels, test_images, test_examples = load_data(
TEST_LABELS, TEST_IMAGES, limit)
layers = params['layers']
output_file = params['output_file']
average_gradient = params['average_gradient']
activation = neuralnet.activations[params['activation']]
nn = neuralnet.NeuralNet(784, layers, activation, average_gradient)
# Uncomment to continue an already started training
#nn.load(params['output_file'])
nb_epochs = params['nb_epochs']
training_rounds = params['rounds_per_epoch']
samples_per_round = params['samples_per_round']
learning_rates = params['learning_rates']
# Each loop takes ~1000s ~= 16m
for epoch in range(0, nb_epochs):
learning_rate = learning_rates[epoch]
score = evaluate_network(nn, test_examples, test_labels, test_images)
print("Epoch %s, Score before: %s, Learning rate: %s" %
(epoch, score, learning_rate))
nn.train(training_rounds, samples_per_round, learning_rate,
train_examples, train_labels)
nn.save(output_file)
def __init__(self, name=None, path=None):
neuron.Neuron.__init__(self, name)
self.Path = path
if path is None:
self.Net = neuralnet.NeuralNet()
else:
self.Net = neuralnetio.NeuralNetIO().read(path)
def testMultipleLayersNetworkActivation(self):
nn = neuralnet.NeuralNet(2, [2, 2], neuralnet.ReLu())
# 1 -- 0.5 --> [-0.1](A) -- 0.7 --> [-0.2](C)
# ^ | ^ |
# | 0.7 | 0.8
# 0.2 | 0.5 |
# | v | v
# 0 -- 0.6 --> [-0.1](B) -- 0.9 --> [-0.3](D)
# (A) = 0.5 - 0.1 = 0.4
# (B) = 0.7 - 0.1 = 0.6
# (C) = 0.4x0.7 + 0.6x0.5 - 0.2 = 0.38
# (D) = 0.9x0.6 + 0.8x0.4 - 0.3 = 0.56
nn.layers[0][0].weights=[0.5, 0.2]
nn.layers[0][0].bias=-0.1
nn.layers[0][1].weights=[0.7, 0.6]
nn.layers[0][1].bias=-0.1
nn.layers[1][0].weights=[0.7, 0.5]
nn.layers[1][0].bias=-0.2
nn.layers[1][1].weights=[0.8, 0.9]
nn.layers[1][1].bias=-0.3
neuronA_output = nn.layers[0][0].output([1, 0], for_training=False)
self.assertAlmostEqual(0.4, neuronA_output)
neuronB_output = nn.layers[0][1].output([1, 0], for_training=False)
self.assertAlmostEqual(0.6, neuronB_output)
output = nn.evaluate([1, 0])
self.assertAlmostEqual(0.38, output[0])
self.assertAlmostEqual(0.56, output[1])
def main():
print("Machine Learning Tutorial 2 - Making a Network")
n = neuralnet.NeuralNet()
x = numpy.array([2, 3])
result = n.feedforward(x)
print(result) # 0.7216325609518421
def league():
"""
현재 존재하는 신경망들끼리 리그 게임을 진행한 후,
승률이 높은 신경망들만 살리고 각각 신경망들의 자손을 만든다.
남은 자리는 다시 랜덤 신경망으로 채운다.
"""
global learningList, leagueNum
leagueNum += 1
winlose = 0
print('[League {}] Start!'.format(leagueNum))
for i in range(LEARNING_COUNT):
learningList[i].winScore = 0
for i in range(LEARNING_COUNT):
for j in range(i + 1, LEARNING_COUNT):
leagueGame = game.Game()
print('[League {}] No.{} vs No.{}'.format(leagueNum, i, j))
while 1:
predict1 = learningList[i].predict(leagueGame, 1)
if predict1 is not None:
leagueGame.place(predict1[0], predict1[1], 1)
predict2 = learningList[j].predict(leagueGame, -1)
if predict2 is not None:
leagueGame.place(predict2[0], predict2[1], -1)
if predict1 is None and predict2 is None:
score = leagueGame.getScore()
if score[0] > score[1]:
learningList[i].winScore += (score[0] - score[1])
elif score[0] < score[1]:
learningList[j].winScore += (score[1] - score[0])
print('[League {}] Game over! {}:{}'.format(leagueNum, score[0], score[1]))
'''
for u in range(8):
for v in range(8):
if leagueGame.gameBoard[u][v] == 1:
print('+', end='')
elif leagueGame.gameBoard[u][v] == -1:
print('-', end='')
else:
print('0', end='')
print('')
'''
if score[0] > score[1]:
winlose += 1
elif score[0] < score[1]:
winlose -= 1
break
print('[League {}] W/L Point: {}'.format(leagueNum, winlose))
learningList.sort(key=lambda nn: nn.winScore, reverse=True)
newLearningList = []
for i in range(WIN_COUNT):
for j in range(i + 1, WIN_COUNT):
newLearningList.append(learningList[i].gen(learningList[j]))
while len(newLearningList) < LEARNING_COUNT:
newLearningList.append(neuralnet.NeuralNet())
learningList = newLearningList
save()
def mutation_intra_layer(self, net):
if not test:
print('net ' + net.get_fnum_gen() + ' intra mutation')
mutated_net = nn.NeuralNet(self.family_num, self.child_num)
mutated_net.set_list_layers(net.get_list_layers(), net.layer_num)
diff = randint(0, int(len(net.list_layers)))
for _ in range(diff):
mutated_net.adjust_layer_attr_random()
return mutated_net
def testTrainAndPredictOnXor(self):
dataset = [
# Both negatives
([-0.5, -0.5], 1),
([-0.5, -0.3], 1),
([-0.5, -0.2], 1),
([-0.3, -0.5], 1),
([-0.3, -0.3], 1),
([-0.3, -0.2], 1),
([-0.2, -0.5], 1),
([-0.2, -0.3], 1),
([-0.2, -0.2], 1),
# First negative, second positive
([-0.5, 0.5], 0),
([-0.5, 0.3], 0),
([-0.5, 0.2], 0),
([-0.3, 0.5], 0),
([-0.3, 0.3], 0),
([-0.3, 0.2], 0),
([-0.2, 0.5], 0),
([-0.2, 0.3], 0),
([-0.2, 0.2], 0),
# Both positives
([0.5, 0.5], 1),
([0.5, 0.3], 1),
([0.5, 0.2], 1),
([0.3, 0.5], 1),
([0.3, 0.3], 1),
([0.3, 0.2], 1),
([0.2, 0.5], 1),
([0.2, 0.3], 1),
([0.2, 0.2], 1),
# First positive, second negative
([0.5, -0.5], 0),
([0.5, -0.3], 0),
([0.5, -0.2], 0),
([0.3, -0.5], 0),
([0.3, -0.3], 0),
([0.3, -0.2], 0),
([0.2, -0.5], 0),
([0.2, -0.3], 0),
([0.2, -0.2], 0),
]
examples = [a[0] for a in dataset]
labels = [a[1] for a in dataset]
nn = neuralnet.NeuralNet(2, [2, 2], neuralnet.Sigmoid())
nn.train(20*20*20, 10, 1.0, examples, labels)
print("")
print(nn.evaluate([0.4, 0.4])) # 1
print(nn.evaluate([-0.3, 0.3])) # 0
print(nn.evaluate([-0.3, -0.4])) # 1
print(nn.evaluate([0.4, -0.4])) # 0
print("")
self.assertEqual(1, nn.predict([0.4, 0.4]))
self.assertEqual(0, nn.predict([-0.3, 0.3]))
self.assertEqual(1, nn.predict([-0.3, -0.4]))
self.assertEqual(0, nn.predict([0.4, -0.4]))
def __init__(self,
surface,
model_filepath=None,
whiskers_on=False,
smell_on=False):
# Assign physical properties
self.health = 1
self.orientation = 0
self.position = np.random.rand(2) * surface.get_size()
self.velocity = np.array([0.0, 0.0],
dtype='float') #np.random.rand(2) * 10 - 5
self.velocity_max = 0.1
self.acceleration = np.array([0, 0], dtype='float')
self.acceleration_max = 0.001
# Assign variables used in draw()
self.draw_velocity = False
self.draw_whiskers = False
self.surface = surface
self.body_draw_size = 6.0
self.velocity_line_length = 1.5
self.colour_inner = np.random.rand(3) * 255
self.colour_outer = np.array([255, 255, 255])
# Assign variables for whiskers()
self.whiskers_on = whiskers_on
self.n_whiskers = 15
self.vision_range = 30
# Assign variables for smell()
self.smell_on = smell_on
self.smell_memory_length = 5
self.smell_memory = range(self.smell_memory_length)
# Assign variables for eat()
self.eat_range = 3
# Assign a neural net as a brain
self.nn_input_size = 0
if self.whiskers_on:
self.nn_input_size += self.n_whiskers
if self.smell_on:
self.nn_input_size += self.smell_memory_length
self.model_filepath = model_filepath
self.brain = neuralnet.NeuralNet(input_size=self.nn_input_size,
output_size=9,
model_filepath=self.model_filepath)
self.state_previous = None
self.action_previous = None
self.reward_previous = 0
def load():
"""
파일에 저장된 학습 데이터를 불러온다.
"""
with open('learn.json', 'r') as jsonFile:
global learningList
loadList = []
for w in json.load(jsonFile):
loadList.append(neuralnet.NeuralNet(w))
learningList = loadList
jsonFile.close()
def create_seed_net(self, num, net_name=None, load_network=None):
# create seed network by name in seed library
seed_net = nn.NeuralNet(0,
num,
net_name=net_name,
load_network=load_network,
create_seed=True,
is_seed=True)
seed_net.kick_simulation()
seed_net.output_deploy_network()
return seed_net
def init():
"""
이미 학습된 데이터가 있다면 불러오고 없으면 새로운 학습 데이터를 만든다.
"""
from pathlib import Path
if Path('learn.json').is_file():
print('File exists')
load()
else:
print('File not exists. Initializing')
for i in range(LEARNING_COUNT):
learningList.append(neuralnet.NeuralNet())
save()
def reverse_evaluate(filename):
nn = neuralnet.NeuralNet(0, [], neuralnet.Sigmoid())
nn.load(filename)
inputs = len(nn.layers[-1])
layers = [len(l) for l in reversed(nn.layers[:-1])]
layers.append(len(nn.layers[0][0].weights))
rev_nn = neuralnet.NeuralNet(inputs, layers, nn.activation)
for li, l in enumerate(nn.layers):
rl = rev_nn.layers[-li - 1]
for ni, n in enumerate(l):
rn = rl[ni]
rn.weights = [0] * len(n.weights)
for wi, w in enumerate(n.weights):
rn.weights[wi] = w
rn.bias = -n.bias
results = []
for i in range(inputs):
inp = [0] * inputs
inp[i] = 1
result = rev_nn.evaluate(inp, for_training=False)
results.append(result)
return results
def cross_to_new_net_point(self):
if not test:
print('net ' + self.father.get_fnum_gen() + ' and net ' +
self.mother.get_fnum_gen() + ' cross new net')
cross_point = randint(0, self.father.get_network_depth())
new_layer_list = self.father.list_layers[:
cross_point] + self.mother.list_layers[
cross_point:]
new_net = nn.NeuralNet(self.family_num, self.child_num)
new_net.set_list_layers(
new_layer_list, max(self.father.layer_num, self.mother.layer_num))
if not test:
c = combine(self.father, self.mother, new_net)
c.combine()
return new_net
def main(data):
nn = NNet.NeuralNet(64, 56, 20)
nn.set_param(0.8, 0.3)
ev = eps + 1
while (eps < ev):
nn.learn(data)
ev = nn.evaluate(data)
print(ev)
print(nn.forward(ds.ldata_a[0][0]))
print(nn.test(ds.ldata_a))
print(nn.test(ds.tdata_a))
print(nn.test(ds.ldata_b))
print(nn.test(ds.tdata_b))
print(nn.test(ds.ldata))
print(nn.test(ds.tdata))
def testTrainOnSimpleExample(self):
# Simple example that only depends on the first parameter.
# A linear separation would be enough but it has the benefit of training fast :-)
""" Created with:
import random
print(random.random()*4, random.random()*5, 0) for i in range(0, 5)
print(5+random.random()*4, random.random()*5, 1) for i in range(0, 5)
"""
dataset = [
([2.7810836, 2.550537003], 0),
([1.465489372, 2.362125076], 0),
([3.396561688, 4.400293529], 0),
([1.38807019, 1.850220317], 0),
([3.06407232, 3.005305973], 0),
([7.627531214, 2.759262235], 1),
([5.332441248, 2.088626775], 1),
([6.922596716, 1.77106367], 1),
([8.675418651, -0.242068655],1),
([7.673756466, 3.508563011], 1),
]
examples = [a[0] for a in dataset]
labels = [a[1] for a in dataset]
nn = neuralnet.NeuralNet(2, [2, 2], neuralnet.Sigmoid())
# This empirically proves to be good parameters to train on this
nn.train(10*20*20, 1, 1.0, examples, labels)
# TODO: This should work like this too:
#nn.train(20*20, 10, 1.0, examples, labels)
"""
print("")
print(nn.evaluate([2, 5]))
print(nn.evaluate([2.5, 2.5]))
print(nn.evaluate([3, 0]))
print(nn.evaluate([6, 0]))
print(nn.evaluate([7.5, 2.5]))
print(nn.evaluate([9, 5]))
print("")
"""
self.assertEqual(0, nn.predict([2, 5]))
self.assertEqual(0, nn.predict([2.5, 2.5]))
# This usually fails pretty badly on this one which is not necessarily surprising: there's no example close to it
#self.assertEqual(0, nn.predict([3, 0]))
self.assertEqual(1, nn.predict([6, 0]))
self.assertEqual(1, nn.predict([7.5, 2.5]))
self.assertEqual(1, nn.predict([9, 5]))
def test_network(filename):
test_labels, test_images, test_examples = load_data(
TEST_LABELS, TEST_IMAGES, None)
labels = set(test_labels)
confusion = [[0] * len(labels) for i in range(len(labels))]
nn = neuralnet.NeuralNet(784, [10],
neuralnet.Sigmoid(),
average_gradient=False)
nn.load(filename)
score = evaluate_network(nn,
test_examples,
test_labels,
test_images,
verbose=False,
confusion=confusion)
print("Score: %s" % score)
show_confusion(confusion)
def read(file_name):
f = open(file_name, 'r')
lines = f.readlines()
depth = int(lines[0].replace('\n', ''))
topology = []
for i in range(1, depth + 1):
topology.append(int(lines[i].replace('\n', '')))
net = nn.NeuralNet(topology)
skip = 0
for l in range(depth - 1):
for i in range(topology[l] + 1):
line = lines[depth + 1 + i + skip].replace('\n', '')
weights = line.split(' ')
for j in range(topology[l + 1]):
net.theta[l][i, j] = float(weights[j])
skip += topology[l] + 1
f.close()
return net
def test(x, y, lam, maxiter, normalize, step):
"""Test the given network on the train and validation sets
Arguments:\n
[X] must be a file path to a CSV which holds your training data\n
[Y] must be a file path to a CSV which holds your expected outputs for the training examples
(neural cli will ommit the first row for column headers for both CSVs)
"""
X = np.loadtxt(x, delimiter=",", skiprows=1, dtype="float")
Y = np.loadtxt(y, delimiter=",", skiprows=1, dtype="float")
nn = neuralnet.NeuralNet(X=X,
Y=Y,
writer=writer,
lam=lam,
maxiter=maxiter,
norm=normalize)
nn.test(step)
def train(x, y, output, lam, maxiter, normalize, verbose):
"""Train a neural network with the given X and Y parameters.
Arguments:\n
[X] must be a file path to a CSV which holds your training data\n
[Y] must be a file path to a CSV which holds your expected outputs for the training examples
(neural cli will ommit the first row for column headers for both CSVs)
"""
X = np.loadtxt(x, delimiter=",", skiprows=1, dtype="float")
Y = np.loadtxt(y, delimiter=",", skiprows=1, dtype="float")
nn = neuralnet.NeuralNet(X=X,
Y=Y,
writer=writer,
output=output,
lam=lam,
maxiter=maxiter,
norm=normalize)
nn.train(verbose=verbose, save=output)
nn.accuracy()
def runNeuralNet(numTrainValues, numTestValues, pixels, tune, useTrainedWeights, info):
"""
runNeuralNet() runs the neural net machine learning algorithm on the MNIST
dataset.
"""
# TODO: Add the rest of the params to function argument.
t = time.clock()
neuralClassifier = neuralnet.NeuralNet(range(10))
print "Loading Testing Data....\n"
trainingData, trainingLabels, validationData, validationLabels, features = loadFeatures.loadTrainingData(numTrainValues, pixels, tune)
print "Loading Testing Data....\n"
testingData, testingLabels = loadFeatures.loadTestingData(numTestValues, pixels)
print "Testing Neural Net....\n"
classifiedData = neuralClassifier.classify(testingData)
test(classifiedData, testingLabels, info)
print "Total Time {0}".format(time.clock() - t)
def _initialize_neural_net(self):
# 新建神经网络
self.net = neuralnet.NeuralNet(self.min_boundary,
self.max_boundary,
archive_dir=self.archive_dir,
start_datetime=self.start_datetime)
self.net.init(self.num_params, self.layer_dims,
self.train_threshold_ratio, self.batch_size,
self.dropout_prob, self.regularisation_coefficient)
# 随机初始化网络多次，选择在窗口参数上 loss 最小的权重
best_loss = float('inf')
for _ in range(self.init_net_weight_num):
self.net.reset_weights()
self.net.fit(self.train_params_set, self.train_costs_set,
self.max_epoch, self.window_params_set,
self.window_costs_set)
loss = self.net.get_loss(self.window_params_set,
self.window_costs_set)
if loss < best_loss:
best_loss = loss
best_weights = self.net.get_weights()
self.net.set_weights(best_weights)
def load(self, start_datetime):
# 加载存档
load_archive_filename = os.path.join(
self.archive_dir,
self.archive_file_prefix + start_datetime + '.txt')
# 从存档中读取参数
print("Loading...")
self._load_archive(load_archive_filename)
# 读取上次保存的典型参数，获取实验结果
self.last_iteration += 1
print("Iteration %d..." % self.last_iteration)
self.init_costs_set = self.get_experiment_costs(self.init_params_set)
# 筛选好的参数放入窗口，最多不超过初始参数的一半
max_size = min(self.window_size, len(self.init_costs_set) // 2)
indexes = np.argsort(self.init_costs_set)
self.window_params_set = self.init_params_set[indexes[:max_size]]
self.window_costs_set = self.init_costs_set[indexes[:max_size]]
self.train_params_set = self.init_params_set[indexes[max_size:]]
self.train_costs_set = self.init_costs_set[indexes[max_size:]]
# 记录典型参数中的最好参数和结果
self.best_params = self.init_params_set[indexes[0]]
self.best_cost = self.init_costs_set[indexes[0]]
# 记入记录列表
self.best_params_list = np.vstack(
(self.best_params_list, self.best_params))
self.best_costs_list = np.hstack(
(self.best_costs_list, self.best_cost))
# 更新档案
self.archive.update({'last_iteration': self.last_iteration})
# 加载神经网络
self.net = neuralnet.NeuralNet(self.min_boundary,
self.max_boundary,
archive_dir=self.archive_dir,
start_datetime=self.start_datetime)
self.net.load(self.archive, self.load_neural_net_archive_filename)
# 存档
self._save_archive()
def predict(x, labels, params, sizeh, normalize):
"""
predict an output with a given row. Prints the index of the prediction of the output row.
Arguments:\n
[x] the file that holds the 1 * n row example that should be predicted \n
[labels] the size of the output layer that the parameters were trained on \n
[params] the file that holds a 1 * n rolled parameter vector \n
"""
x = np.loadtxt(x, delimiter=",", skiprows=0, dtype="float")
x = x[np.newaxis]
nn = neuralnet.NeuralNet(X=None, Y=None, writer=writer, norm=normalize)
input_size = np.shape(x)[1]
hidden_size = input_size
if sizeh:
hidden_size = sizeh
nn.set_hidden_size(input_size)
nn.set_hidden_size(hidden_size)
nn.set_num_labels(labels)
nn.set_params(np.loadtxt(params, delimiter=",", skiprows=0, dtype="float"))
print nn.predict(x)
imageWidth,
imageHeight,
fill="white",
outline="white")
draw.rectangle([0, 0, imageWidth, imageHeight],
fill=white,
outline=white)
def handleKey(self, event):
if repr(event.char) == CTRLA:
self.clearCanvas()
#Load neural network
t = time.time()
print "Loading neural network..."
net = neuralnet.NeuralNet()
net.LoadData(netName)
print "Done!",
print "Loaded in ", time.time() - t, "seconds.."
root = Tk()
root.title("Digit Recognition")
root.resizable(0, 0)
uiFrame = Demo(root)
uiFrame.pack()
root.bind("<Control-Key>", uiFrame.handleKey)
root.mainloop()
import neuralnet as n import numpy as np net = n.NeuralNet([2, 4, 1]) net.train(np.array([[0, 1]]), np.array([[1]]))
def f(x):
return (0.5 * np.sin(x)) + 0.5, (0.3 * np.cos(x)) + 0.3
# create train samples
xtrain = np.linspace(-7, 7, numTrain).reshape(numTrain, 1)
ytrain = np.zeros([numTrain, 2])
ytrain[:, 0] = f(xtrain)[0].squeeze()
ytrain[:, 1] = f(xtrain)[1].squeeze()
# Instantiate neural network with 2 layers.
# The hidden layer has 5 neurons, with 1 output.
# assumes full connectivity between layer neurons.
# uses sigmoid activation function by default at each layer.
net = nn.NeuralNet([1, 100, 50, 2],
actFunc=[act.Sigmoid(),
act.Sigmoid(),
act.ArcTan()])
# hire a trainer for the network
trainer = nn.Trainer(net, 'SSE', 25, xtrain, ytrain)
# train using BFGS and sum of squares error
#optArgs = {'gtol': 1e-6, 'maxiter': 250}
#trainer.trainBFGS(**optArgs)
optArgs = {
'bounds': None,
'm': 1000,
'factr': 1e7,
'pgtol': 1e-02,
'iprint': 1,
if __name__ == '__main__':
datasets_dict = load_mnist('')
# print each dataset's shape
for dataset_type in datasets_dict:
print(dataset_type, datasets_dict[dataset_type].shape)
print('\n')
training_data = datasets_dict['train']
validation_data = datasets_dict['validation']
test_data = datasets_dict['test']
#_display_digits(datasets_dict)
#_display_digits(datasets_dict, plot_type='same_digit', digit=8)
#_display_digits_distrib(datasets_dict)
# transform each dataframe into a numpy.ndarray to be used by the neural net
training_data_list = _df_to_ndarray(training_data, dataset_type='training')
test_data_list = _df_to_ndarray(test_data, dataset_type='test')
validation_data_list = _df_to_ndarray(validation_data, dataset_type='validation')
nn = neuralnet.NeuralNet([784, 30, 10])
nn._stochastic_gd(training_data_list, 30, 10, 1.0, validation_data=validation_data_list)
n_test = len(validation_data)
test_data_eval = nn.evaluate(test_data_list)
print('evaluation for the test dataset: {} / {}'.format(test_data_eval, n_test))
#The values 0.1307 and 0.3081 are the global mean and standard deviation of the MNIST dataset
