def train_with_train_valid_data():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# Concat train and valid dataset
train_valid_data = [[], []]
train_data[0].extend(valid_data[0])
train_data[1].extend(valid_data[1])
# train_valid_data.append(train_data[0] + valid_data[0])
# train_valid_data.append(train_data[1] + valid_data[1])
print(len(train_data[0]))
print(len(train_data[1]))
# construct the network
model = network2.Network([784, 20, 10])
# train the network using SGD
model.SGD(training_data=train_data,
epochs=20,
mini_batch_size=128,
eta=7e-3,
lmbda=0.0,
evaluation_data=None,
monitor_evaluation_cost=False,
monitor_evaluation_accuracy=False,
monitor_training_cost=False,
monitor_training_accuracy=True)
model.save('../../sgd_model_opt.json')
def run_network(filename, num_epochs, training_set_size=1000, lmbda=0.0):
"""Train the network for ``num_epochs`` on ``training_set_size``
images, and store the results in ``filename``. Those results can
later be used by ``make_plots``. Note that the results are stored
to disk in large part because it's convenient not to have to
``run_network`` each time we want to make a plot (it's slow).
"""
# Make results more easily reproducible
random.seed(12345678)
np.random.seed(12345678)
training_data, validation_data, test_data = mnist_loader.load_data_wrapper(
)
net = network2.Network([784, 30, 10], cost=network2.CrossEntropyCost())
net.large_weight_initializer()
test_cost, test_accuracy, training_cost, training_accuracy \
= net.SGD(training_data[:training_set_size], num_epochs, 10, 0.5,
evaluation_data=test_data, lmbda = lmbda,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
f = open(filename, "w")
json.dump([test_cost, test_accuracy, training_cost, training_accuracy], f)
f.close()
def main(phase):
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# pdb.set_trace()
# construct the network
model = network2.Network([784, 20, 10])
# train the network using SGD
if phase == "train":
result = model.SGD(training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=1e-3,
lmbda=0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
show_metric_plot(result[2], result[0], 100, 'Training Error',
'Validation Error', 'Loss', 'Loss v/s Epochs')
evaluation_accuracy = list(map(lambda x: x * 100 / 10000, result[1]))
training_accuracy = list(map(lambda x: x * 100 / 3000, result[3]))
show_metric_plot(training_accuracy, evaluation_accuracy, 100,
'Training Accuracy', 'Validation Accuracy',
'Accuracy %', 'Accuracy v/s Epochs')
model.save('train_model')
if phase == "test":
net = network2.load('train_model')
print('Accuracy for Test Data:{}%'.format(
net.accuracy(test_data) / 100))
def gradient_check():
train_data, valid_data, test_data = load_data()
model = network2.Network([784, 20, 10])
model.gradient_check(training_data=train_data,
layer_id=1,
unit_id=5,
weight_id=3)
def run_networks():
"""Train networks using three different values for the learning rate,
and store the cost curves in the file ``multiple_eta.json``, where
they can later be used by ``make_plot``.
"""
# Make results more easily reproducible
random.seed(12345678)
np.random.seed(12345678)
training_data, validation_data, test_data = mnist_loader.load_data_wrapper(
)
results = []
for eta in LEARNING_RATES:
print("\nTrain a network using eta = " + str(eta))
net = network2.Network([784, 30, 10])
results.append(
net.SGD(training_data,
NUM_EPOCHS,
10,
eta,
lmbda=5.0,
evaluation_data=validation_data,
monitor_training_cost=True))
f = open("multiple_eta.json", "w")
json.dump(results, f)
f.close()
def gradient_check():
train_data, valid_data, test_data = load_data()
model = network2.Network([784, 20, 15, 10]) # modified
# model = network2.Network([784, 20, 10]) # original
model.gradient_check(training_data=train_data,
layer_id=1,
unit_id=3,
weight_id=3) # modified
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784,30,10])
# train the network using SGD
evaluation_cost,evaluation_accuracy,training_cost,training_accuracy,epochs=model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=1e-3,
lmbda = 0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
prediction=[np.argmax(model.feedforward(test_data[0][x])) for x in range(len(test_data[0]))]
accuracy=model.accuracy(test_data,convert='False')
ohe=[network2.vectorized_result(i) for i in prediction]
with open('predictions.csv','w',newline='') as csvfile:
record=csv.writer(csvfile)
for i in ohe:
record.writerow(int(j) for j in (i))
plt.figure()
plt.plot(range(epochs),evaluation_cost,range(epochs),training_cost)
plt.legend(('evaluation_cost','traning_cost'),loc='upper right')
plt.title('loss trend')
plt.xlabel('Epochs')
plt.ylabel('Cost')
plt.show()
plt.figure()
plt.plot(range(epochs),evaluation_cost,range(epochs),training_cost)
plt.legend(('evaluation_accuracy','traning_accuracy'),loc='upper right')
plt.title('accuracy trend')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.show()
#Testing the trained model
n=len(test_data[0])
accuracy=model.accuracy(test_data)
print("[Testing Accuracy]: {} / {}".format(accuracy,n))
results=[np.argmax(model.feedforward(test_data[0][x])) for x in range(len(test_data[0]))]
results=np.array(results)
m=results.max() +1
results=np.eye(m)[results]
#print(results)
np.savetxt("predictions.csv",results,fmt="%d",delimiter=",") # using %d to convert the floating point values to int and store in the csv file
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 300, 100, 10])
# train the network using SGD
num_epochs = 100
lr = 3e-3
[val_loss, val_acc, train_loss,
train_acc] = model.SGD(training_data=train_data,
epochs=num_epochs,
mini_batch_size=128,
eta=lr,
lmbda=0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
_predict(model, test_data)
model.save('weights.json')
plt.subplots_adjust(hspace=0.5)
plt.subplot(2, 1, 1)
plt.title("Loss (Eta = %.4f)" % lr)
plt.xlabel('Epochs')
plt.ylabel('Loss')
line1, = plt.plot(train_loss, label='Train Loss')
line2, = plt.plot(val_loss, label='Validation Loss')
plt.legend(handles=[line1, line2])
plt.grid()
train_acc = np.array(train_acc)
val_acc = np.array(val_acc)
train_acc = train_acc / 30.0
val_acc = val_acc / 100.0
plt.subplot(2, 1, 2)
plt.title("Accuracy (Eta = %.4f)" % lr)
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
line1, = plt.plot(train_acc, label='Train Accuracy')
line2, = plt.plot(val_acc, label='Validation Accuracy')
plt.legend(handles=[line1, line2])
plt.grid()
plt.show()
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 40, 20, 10])
# train the network using SGD
evaluation_cost, evaluation_accuracy, \
training_cost, training_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=1e-3,
lmbda = 0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
plt.figure()
plt.subplot(2, 2, 1)
plt.plot(evaluation_cost)
plt.title('Evaluation Cost')
plt.subplot(2, 2, 2)
plt.plot(evaluation_accuracy)
plt.title('Evaluation Accuracy')
plt.subplot(2, 2, 3)
plt.plot(training_cost)
plt.title('Training Cost')
plt.subplot(2, 2, 4)
plt.plot(training_accuracy)
plt.title('Training Accuracy')
plt.show()
predictions = []
for i in range(len(test_data[0])):
prediction = np.argmax(model.feedforward(test_data[0][i]))
predictions.append(prediction)
output = np.zeros([10000, 10])
for i in range(len(predictions)):
output[i, :] = np.reshape(network2.vectorized_result(predictions[i]),
10)
df = pd.DataFrame(output)
df.to_csv("prediction_3_layer.csv", header=None, index=False)
def main():
# Load the data
full_td, _, _ = mnist_loader.load_data_wrapper()
td = full_td[:1000] # Just use the first 1000 items of training data
epochs = 500 # Number of epochs to train for
print("\nTwo hidden layers:")
net = network2.Network([784, 30, 30, 10])
initial_norms(td, net)
abbreviated_gradient = [
ag[:6] for ag in get_average_gradient(net, td)[:-1]]
print("Saving the averaged gradient for the top six neurons in each " + \
"layer.\nWARNING: This will affect the look of the book, so be " + \
"sure to check the\nrelevant material (early chapter 5).")
f = open("initial_gradient.json", "w")
json.dump(abbreviated_gradient, f)
f.close()
shutil.copy("initial_gradient.json", "../../js/initial_gradient.json")
training(td, net, epochs, "norms_during_training_2_layers.json")
plot_training(
epochs, "norms_during_training_2_layers.json", 2)
print("\nThree hidden layers:")
net = network2.Network([784, 30, 30, 30, 10])
initial_norms(td, net)
training(td, net, epochs, "norms_during_training_3_layers.json")
plot_training(
epochs, "norms_during_training_3_layers.json", 3)
print("\nFour hidden layers:")
net = network2.Network([784, 30, 30, 30, 30, 10])
initial_norms(td, net)
training(td, net, epochs,
"norms_during_training_4_layers.json")
plot_training(
epochs, "norms_during_training_4_layers.json", 4)
def train():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 50, 20, 16, 10])
# train the network using SGD
e = 100
eval_cost, eval_accuracy, train_cost, train_accuracy = model.SGD(
training_data=train_data,
epochs=e,
mini_batch_size=50,
eta=1e-3,
lmbda=0.001,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
#Saving the Neuaral Network
model.save('NeuralNet_new_fc.csv')
#Saving the errors vs Epcoh data
SaveCsv = {
'Evaluation Cost': eval_cost,
'Evaluation Accuracy': eval_accuracy,
'Train Cost': train_cost,
'Train Accuracy': train_accuracy
}
df = pd.DataFrame(SaveCsv)
df.to_csv('Error_Details_layers_new_fc' + '.csv')
#Visualising the error vs epoch
plt.figure()
x = [i for i in range(0, e)]
ax = plt.subplot(1, 2, 1)
ax.plot(x, train_cost, 'r-', label='Training Cost')
ax.plot(x, eval_cost, 'b-', label='Evaluation Cost')
plt.title('Error comparision plot')
#plt.legend()
ay = plt.subplot(1, 2, 2)
ay.plot(x, train_accuracy, 'r-', label='Training accuracy')
ay.plot(x, eval_accuracy, 'b-', label='Evaluation accuracy')
plt.title('Classification comparision plot')
#plt.legend()
plt.show()
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 20, 10])
# train the network using SGD
model.SGD(training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=1e-3,
lmbda=0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
def main():
train_data, valid_data, test_data = load_data()
model = network2.Network([784,80,10])
# train the network using SGD
e_cost, e_accuracy, t_cost, t_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=16,
eta=6e-4,
lmbda = 0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
num_correct = 0
plt.plot(list(range(0,len(t_accuracy))),[x/len(train_data[0]) for x in t_accuracy], label='Training')
plt.plot(list(range(0,len(e_accuracy))),[x/len(valid_data[0]) for x in e_accuracy], label='Validation')
legend = plt.legend(loc='upper left', shadow=True)
plt.title("Learning curve for Accuracy")
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.savefig('accuracy')
plt.clf()
plt.plot(list(range(0,len(t_cost))),t_cost,label='Training')
plt.plot(list(range(0,len(e_cost))),e_cost,label='Validation')
legend = plt.legend(loc='upper left', shadow=True)
plt.title(" Learning curve for Loss")
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.savefig('loss')
plt.clf()
for i in range(len(test_data[0])):
prediction = np.argmax(model.feedforward(test_data[0][i]))
if prediction == test_data[1][i]:
num_correct += 1
test_accuracy = num_correct / len(test_data[0])
print("Test accuracy: " + str(test_accuracy))
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 32, 10])
# train the network using SGD
eval_cost, eval_accuracy,train_cost, train_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=64,
eta=1e-2,
lmbda = 0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
test_total = model.accuracy(test_data, convert=False)
results = [np.argmax(model.feedforward(x))
for (x, y) in zip(*test_data)]
one_hot = [network2.vectorized_result(i) for i in results]
with open('predictions.csv', 'w', newline='') as csvfile:
spamwriter = csv.writer(csvfile)
for i in one_hot:
spamwriter.writerow(int(j) for j in i)
print("Testing: {}/{}".format(test_total,len(test_data[0])))
# Plot Learning curves
print("PLOTING")
#Loss
plt.plot(list(range(len(eval_cost))),eval_cost,'b-',list(range(len(train_cost))),train_cost,'r-')
plt.legend(('Validation Loss','Training Loss'))
plt.title("Loss Curve: batch=128, eta=e-2, hl=20")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.show()
#Error
plt.plot(list(range(len(eval_accuracy))),[x/len(valid_data[0]) for x in eval_accuracy],'b-',list(range(len(train_accuracy))),[x/len(train_data[0]) for x in train_accuracy],'r-')
plt.legend(('Validation Accuracy','Training Accuracy'))
plt.title("Accuracy Curve: batch=128, eta=e-2, hl=20")
plt.xlabel("Epochs")
plt.ylabel("Accuracy")
plt.show()
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 20, 10])
# train the network using SGD
epoch_size = 100
ev_cost, ev_acc, train_cost, train_acc = model.SGD(
training_data=train_data,
epochs=epoch_size,
mini_batch_size=128,
eta=7e-3,
lmbda=0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
model.save('../../sgd_model.json')
z = np.arange(0, epoch_size, 1)
fig = plt.figure()
plt.subplots_adjust(hspace=0.6, wspace=0.4)
plt.subplot(2, 2, 1)
plt.plot(z, train_cost)
plt.title('training')
plt.ylabel('cost')
plt.subplot(2, 2, 2)
plt.plot(z, ev_cost)
plt.title('validation')
plt.subplot(2, 2, 3)
plt.plot(z, train_acc)
plt.ylabel('accuracy')
plt.subplot(2, 2, 4)
plt.plot(z, ev_acc)
fig.text(0.5, 0.04, 'epoch size', ha='center')
plt.show()
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 100, 10])
# train the network using SGD
print(model)
evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=5e-3,
lmbda=0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
plt.figure()
plt.plot(training_cost)
plt.xlabel("epochs")
plt.ylabel("Cost")
plt.title('Cost during training')
plt.show()
plt.figure()
plt.plot(training_accuracy)
plt.title('Accuracy during training')
plt.xlabel("epochs")
plt.ylabel("Accuracy")
plt.show()
plt.figure()
plt.plot(evaluation_cost)
plt.title('Cost during validation')
plt.xlabel("epochs")
plt.ylabel("Cost")
plt.show()
plt.figure()
plt.plot(evaluation_accuracy)
plt.title('Accuracy during validation')
plt.xlabel("epochs")
plt.ylabel("Accuracy")
plt.show()
model.save("weights.json")
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 20, 10])
#model = network2.load('saver')
#train the network using SGD
evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=0.5e-3,
lmbda = 0.0,
evaluation_data=test_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
training_accuracy = np.divide(training_accuracy, len(train_data[0]))*100
evaluation_accuracy = np.divide(evaluation_accuracy, len(test_data[0]))*100
fig1, ax1 = plt.subplots()
ax1.plot(training_cost, 'k', label = 'Training cost')
ax1.plot(evaluation_cost, 'r', label = 'Validation cost')
ax1.legend()
plt.title('Training cost vs Evaluation cost')
legend1 = ax1.legend(loc='upper center', fontsize='medium')
plt.ylabel('Cost')
plt.xlabel('Number of epochs')
plt.savefig('Cost')
plt.show()
fig2, ax2 = plt.subplots()
ax2.plot(training_accuracy, 'k', label = 'Training accuracy')
ax2.plot(evaluation_accuracy, 'r', label = 'Validation accuracy')
ax2.legend()
plt.title('Training accuracy vs Evaluation accuracy')
legend2 = ax2.legend(loc='upper left', fontsize='medium')
plt.ylabel('Accuracy (%)')
plt.xlabel('Number of epochs')
plt.savefig('Accuracy')
plt.show()
model.save('saver')
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 20,10])
# train the network using SGD
e_c,e_a,t_c,t_a=model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=256,
eta=1e-3,
lmbda = 0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
model.save('Saved_Weights')
plt.figure(1)
e_c_plot = np.squeeze(e_c)
t_c_plot = np.squeeze(t_c)
plt.plot(e_c_plot,'r',label="Validation")
plt.plot(t_c_plot,'b',label="Training")
plt.ylabel('Cost')
plt.xlabel('Epochs')
plt.title("Learning Curve: cost vs epochs")
plt.legend(loc='upper center')
plt.show()
plt.figure(2)
e_a_plot = np.squeeze(e_a)
t_a_plot = np.squeeze(t_a)
plt.plot(e_a_plot,'r',label="Validation")
plt.plot(t_a_plot,'b',label="Training")
plt.ylabel('Accuracy')
plt.xlabel('Epochs')
plt.title("Learning Curve: accuracy vs epochs")
plt.legend(loc='lower right')
plt.show()
def run_networks():
# Make results more easily reproducible
random.seed(12345678)
np.random.seed(12345678)
training_data, validation_data, test_data = mnist_loader.load_data_wrapper(
)
net = network2.Network([784, 30, 10], cost=network2.CrossEntropyCost())
accuracies = []
for size in SIZES:
print
"\n\nTraining network with data set size %s" % size
net.large_weight_initializer()
num_epochs = 1500000 / size
net.SGD(training_data[:size], num_epochs, 10, 0.5, lmbda=size * 0.0001)
accuracy = net.accuracy(validation_data) / 100.0
print
"Accuracy was %s percent" % accuracy
accuracies.append(accuracy)
f = open("more_data.json", "w")
json.dump(accuracies, f)
f.close()
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 20, 10])
# train the network using SGD
evaluation_cost, evaluation_accuracy, \
training_cost, training_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=32,
eta=1e-3,
lmbda = 0.00,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
training_accuracy = list(
map(lambda x: x / len(train_data[0]), training_accuracy))
evaluation_accuracy = list(
map(lambda x: x / len(valid_data[0]), evaluation_accuracy))
plt.plot(training_accuracy, label='Training Accuracy')
plt.plot(evaluation_accuracy, label='Validation Accuracy')
plt.legend(loc='best')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.savefig('accuracy.png')
plt.clf()
plt.plot(training_cost, label='Training Cost')
plt.plot(evaluation_cost, label='Validation Cost')
plt.legend(loc='best')
plt.xlabel('Epoch')
plt.ylabel('Cost')
plt.savefig('cost.png')
model.save('final_model.json')
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 32, 10])
# train the network using SGD
validation_loss , validation_accuracy, training_loss, training_accuracy = model.SGD(
training_data=train_data,
epochs=75,
mini_batch_size=64,
eta=0.002,
lmbda = 0.0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
model.save("model0.json")
model = network2.load("model0.json")
predictions , prob, vector_base = predict(test_data, model)
plot_learning_curve(validation_loss, training_loss, validation_accuracy, training_accuracy)
csvfile = open('predictions.csv','w', newline='')
obj = csv.writer(csvfile)
obj.writerows(predictions)
csvfile.close()
csvfile = open('raw.csv','w', newline='')
obj1 = csv.writer(csvfile)
obj1.writerows(prob)
csvfile.close()
test_accuracy = 0;
for x, y in zip(vector_base, test_data[1]):
if x == y:
test_accuracy += 1
print("The accuracy on test set is: " , test_accuracy)
def main():
# load train_data, valid_data, test_data
train_data, valid_data, test_data = load_data()
# construct the network
model = network2.Network([784, 20, 10])
# train the network using SGD
eval_cost, eval_accuracy, training_cost, training_accuracy = model.SGD(
training_data=train_data,
epochs=100,
mini_batch_size=128,
eta=1e-3,
lmbda=0,
evaluation_data=valid_data,
monitor_evaluation_cost=True,
monitor_evaluation_accuracy=True,
monitor_training_cost=True,
monitor_training_accuracy=True)
for k in range(len(training_accuracy)):
training_accuracy[k] = training_accuracy[k] / len(train_data[0])
eval_accuracy[k] = eval_accuracy[k] / len(valid_data[0])
model.save("train.data")
# Plot Learning curves
print("PLOTING")
#Training Loss
plt.plot(list(range(0, len(model.training_loss_l))), model.training_loss_l)
plt.title("Training Loss Curve")
plt.savefig('training_loss')
#plt.show()
plt.clf()
#Training accuracy
plt.plot(list(range(0, len(training_accuracy))), training_accuracy)
plt.title("Training Accuracy Curve")
plt.savefig('training_accuracy')
#plt.show()
plt.clf()
#Validation Loss
plt.plot(list(range(0, len(model.validation_loss_l))),
model.validation_loss_l)
plt.title("Validation Loss Curve")
plt.savefig('validation_loss')
#plt.show()
plt.clf()
#Validation Accuracy
plt.plot(list(range(0, len(eval_accuracy))), eval_accuracy)
plt.title("Validation Accuracy Curve")
plt.savefig('eval_accuracy')
#plt.show()
plt.clf()
# Evaluate test data
num_correct = 0
for i in range(len(test_data[0])):
prediction = np.argmax(model.feedforward(test_data[0][i]))
if prediction == test_data[1][i]:
num_correct += 1
test_accuracy = num_correct / len(test_data[0])
print("Test accuracy: " + str(test_accuracy))
import src.mnist_loader as mnist_loader
import src.network as network
import src.network2 as network2
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
# Network 1
# net = network.Network([784, 30, 10])
# net.SGD(training_data, 30, 10, 3.0, test_data=test_data)
# Network 2
net = network2.Network([784, 30, 10])
evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = net.SGD(
training_data,
30,
10,
0.5,
lmbda=5.0,
evaluation_data=validation_data,
monitor_evaluation_accuracy=True,
monitor_evaluation_cost=True,
monitor_training_accuracy=True,
monitor_training_cost=True)
"""
Moduł służący do śledzenia postępów sieci neuronowej zaimplementowanej w module netowrk2.py
"""
import src.mnist_loader as mnist_loader
import src.network2 as network2
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
net = network2.Network([784, 20, 10], cost=network2.CrossEntropyCost)
net.large_weight_initializer()
net.SGD(training_data=training_data,
epochs=50,
mini_batch_size=10,
eta=0.1,
lmbda=5.0,
evaluation_data=list(validation_data)[:100],
monitor_evaluation_accuracy=True)
