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 = network1.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 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 = network1.Network([784, 30, 10], cost=network1.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 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 = network1.Network([784, 30, 10], cost=network1.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()
if xlim != None:
axes.set_xlim(xlim) # x-axis bounds
if ylim != None:
axes.set_ylim(ylim) # y-axis bounds
if title != None:
plt.title(title, fontdict=titlefont)
if xlab != None:
plt.xlabel(xlab, fontdict=labelfont)
if ylab != None:
plt.ylabel(ylab, fontdict=labelfont)
if fname != None:
plt.savefig(fname, bbox_inches='tight')
plt.show()
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
print("MNIST data is loaded...")
exp_path = 'data/experiment/'
nist_exp_path = 'data/experiment/nist/'
num_exp = 10
epochs = 50
mini_batch = 10
learn_rate = 3.0
exp = 'nist_rfa'
" " " MSE network with sigmoid output layer " " "
if exp == 'nist_mse':
all_loss = []
all_eval = []
net = Network(data["sizes"], cost=cost)
net.weights = [np.array(w) for w in data["weights"]]
net.biases = [np.array(b) for b in data["biases"]]
return net
def sigmoid(z):
return 1.0 / (1.0 + np.exp(-z))
def sigmoid_prime(z):
return sigmoid(z) * (1 - sigmoid(z))
if __name__ == "__main__":
training_data, validation_data, test_data = mnist_loader.load_data_wrapper(
)
net = Network([784, 30, 10], cost=CrossEntropyCost)
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)
print(f"Evaluation cost: {evaluation_cost}")
print(f"Evaluation accuracy: {evaluation_accuracy}")
print(f"Training cost: {training_cost}")