{"id":986,"date":"2019-01-22T10:52:25","date_gmt":"2019-01-22T02:52:25","guid":{"rendered":"http:\/\/www.max-shu.com\/blog\/?p=986"},"modified":"2019-01-22T10:52:25","modified_gmt":"2019-01-22T02:52:25","slug":"%e3%80%8a%e7%a5%9e%e7%bb%8f%e7%bd%91%e7%bb%9c%e4%b8%8e%e6%b7%b1%e5%ba%a6%e5%ad%a6%e4%b9%a0%e3%80%8b%e4%b8%ad%e7%9a%84python-3-x-%e4%bb%a3%e7%a0%81network2-py","status":"publish","type":"post","link":"http:\/\/www.max-shu.com\/blog\/?p=986","title":{"rendered":"\u300a\u795e\u7ecf\u7f51\u7edc\u4e0e\u6df1\u5ea6\u5b66\u4e60\u300b\u4e2d\u7684Python 3.x \u4ee3\u7801network2.py"},"content":{"rendered":"

\u300a\u795e\u7ecf\u7f51\u7edc\u4e0e\u6df1\u5ea6\u5b66\u4e60\u300b\uff08Michael Nielsen<\/span>\u8457<\/span>\uff09\u4e2d\u7684\u4ee3\u7801\u662f\u57fa\u4e8epython2.7\u7684\uff0c\u4e0b\u9762\u4e3a\u79fb\u690d\u5230python3\u4e0b\u7684\u4ee3\u7801\uff1a<\/p>\n

network2.py\u4ee3\u7801\uff1a<\/strong><\/span><\/p>\n

\u70b9\u51fb\u4e0b\u8f7d\uff1anetwork2<\/a><\/strong><\/span><\/p>\n

\n
<\/div>\n
“””network2.py<\/div>\n
~~~~~~~~~~~~~~<\/div>\n
An improved version of network.py, implementing the stochastic<\/div>\n
gradient descent learning algorithm for a feedforward neural network.<\/div>\n
Improvements include the addition of the cross-entropy cost function,<\/div>\n
regularization, and better initialization of network weights. Note<\/div>\n
that I have focused on making the code simple, easily readable, and<\/div>\n
easily modifiable. It is not optimized, and omits many desirable<\/div>\n
features.<\/div>\n
“””<\/div>\n
#### Libraries<\/div>\n
# Standard library<\/div>\n
import json<\/div>\n
import random<\/div>\n
import sys<\/div>\n
# Third-party libraries<\/div>\n
import numpy as np<\/div>\n
import time<\/div>\n
#### Define the quadratic and cross-entropy cost functions<\/div>\n
class QuadraticCost(object):<\/div>\n
@staticmethod<\/div>\n
deffn(a, y):<\/div>\n
“””Return the cost associated with an output “a“ and desired output<\/div>\n
“y“.<\/div>\n
“””<\/div>\n
return0.5*np.linalg.norm(a-y)**2<\/div>\n
@staticmethod<\/div>\n
defdelta(z, a, y):<\/div>\n
“””Return the error delta from the output layer.”””<\/div>\n
return (a-y) * sigmoid_prime(z)<\/div>\n
class CrossEntropyCost(object):<\/div>\n
@staticmethod<\/div>\n
deffn(a, y):<\/div>\n
“””Return the cost associated with an output “a“ and desired output<\/div>\n
“y“. Note that np.nan_to_num is used to ensure numerical<\/div>\n
stability. In particular, if both “a“ and “y“ have a 1.0<\/div>\n
in the same slot, then the expression (1-y)*np.log(1-a)<\/div>\n
returns nan. The np.nan_to_num ensures that that is converted<\/div>\n
to the correct value (0.0).<\/div>\n
“””<\/div>\n
return np.sum(np.nan_to_num(-y*np.log(a)-(1-y)*np.log(1-a)))<\/div>\n
@staticmethod<\/div>\n
defdelta(z, a, y):<\/div>\n
“””Return the error delta from the output layer. Note that the<\/div>\n
parameter “z“ is not used by the method. It is included in<\/div>\n
the method’s parameters in order to make the interface<\/div>\n
consistent with the delta method for other cost classes.<\/div>\n
“””<\/div>\n
return (a-y)<\/div>\n
#### Main Network class<\/div>\n
class Network(object):<\/div>\n
def__init__(self, sizes, cost=CrossEntropyCost):<\/div>\n
“””The list “sizes“ contains the number of neurons in the respective<\/div>\n
layers of the network. For example, if the list was [2, 3, 1]<\/div>\n
then it would be a three-layer network, with the first layer<\/div>\n
containing 2 neurons, the second layer 3 neurons, and the<\/div>\n
third layer 1 neuron. The biases and weights for the network<\/div>\n
are initialized randomly, using<\/div>\n
“self.default_weight_initializer“ (see docstring for that<\/div>\n
method).<\/div>\n
“””<\/div>\n
self.num_layers =len(sizes)<\/div>\n
self.sizes = sizes<\/div>\n
self.default_weight_initializer()<\/div>\n
self.cost=cost<\/div>\n
defprint_init_bias_weight(self):<\/div>\n
print(“Time: “+str(time.strftime(‘%Y-%m-%d %H:%M:%S’,time.localtime(time.time()))))<\/div>\n
print(“\u8f93\u5165\u56fe\u7247\u50cf\u7d20\u70b9\u6570\uff1a”+str(self.sizes[0]) +”, \u8f93\u5165\u795e\u7ecf\u7f51\u7edc\u5c42\u6570\uff1a”+str(self.num_layers))<\/div>\n
print(“\u7b2c 1 \u5c42\u4e3a\u8f93\u5165\u5c42\uff08\u5171 “+str(self.sizes[0])+” \u4e2a\u795e\u7ecf\u5143\uff09\uff0c\u6743\u91cd\u548c\u504f\u7f6e\u90fd\u4e0d\u9700\u8981\u3002”)<\/div>\n
for i inrange(1, self.num_layers):<\/div>\n
print(“\u7b2c “+str(i+1)+” \u5c42\u5171\u6709 “+str(self.sizes[i])+” \u4e2a\u795e\u7ecf\u5143\uff0c\u521d\u59cb\u6743\u91cd\u548c\u504f\u7f6e\u5982\u4e0b\u3002”)<\/div>\n
print(” “)<\/div>\n
layer = 1<\/div>\n
print(“\u8bad\u7ec3\u524d\u7684\u6743\u91cd\u548c\u504f\u7f6e\uff1a”)<\/div>\n
for lw, lb inzip(self.weights, self.biases):<\/div>\n
layer += 1<\/div>\n
num_nw = 0<\/div>\n
for w, b inzip(lw, lb):<\/div>\n
num_nw += 1<\/div>\n
print(“\u7b2c “+str(layer)+” \u5c42\u7b2c “+str(num_nw)+” \u4e2a\u795e\u7ecf\u5143\u7684\u6743\u91cd(\u5171”+str(len(w))+”\u4e2a\u8f93\u5165)\uff1a”)<\/div>\n
print(str(w))<\/div>\n
print(“\u7b2c “+str(layer)+” \u5c42\u7b2c “+str(num_nw)+” \u4e2a\u795e\u7ecf\u5143\u7684\u504f\u7f6e(\u5171”+str(len(b))+”\u4e2a\u8f93\u51fa)\uff1a”)<\/div>\n
print(str(b))<\/div>\n
print(” “)<\/div>\n
print(” “)<\/div>\n
defdefault_weight_initializer(self):<\/div>\n
“””Initialize each weight using a Gaussian distribution with mean 0<\/div>\n
and standard deviation 1 over the square root of the number of<\/div>\n
weights connecting to the same neuron. Initialize the biases<\/div>\n
using a Gaussian distribution with mean 0 and standard<\/div>\n
deviation 1.<\/div>\n
Note that the first layer is assumed to be an input layer, and<\/div>\n
by convention we won’t set any biases for those neurons, since<\/div>\n
biases are only ever used in computing the outputs from later<\/div>\n
layers.<\/div>\n
“””<\/div>\n
self.biases = [np.random.randn(y, 1) for y inself.sizes[1:]]<\/div>\n
self.weights = [np.random.randn(y, x)\/np.sqrt(x)<\/div>\n
for x, y inzip(self.sizes[:-1], self.sizes[1:])]<\/div>\n
deflarge_weight_initializer(self):<\/div>\n
“””Initialize the weights using a Gaussian distribution with mean 0<\/div>\n
and standard deviation 1. Initialize the biases using a<\/div>\n
Gaussian distribution with mean 0 and standard deviation 1.<\/div>\n
Note that the first layer is assumed to be an input layer, and<\/div>\n
by convention we won’t set any biases for those neurons, since<\/div>\n
biases are only ever used in computing the outputs from later<\/div>\n
layers.<\/div>\n
This weight and bias initializer uses the same approach as in<\/div>\n
Chapter 1, and is included for purposes of comparison. It<\/div>\n
will usually be better to use the default weight initializer<\/div>\n
instead.<\/div>\n
“””<\/div>\n
self.biases = [np.random.randn(y, 1) for y inself.sizes[1:]]<\/div>\n
self.weights = [np.random.randn(y, x)<\/div>\n
for x, y inzip(self.sizes[:-1], self.sizes[1:])]<\/div>\n
deffeedforward(self, a):<\/div>\n
“””Return the output of the network if “a“ is input.”””<\/div>\n
for b, w inzip(self.biases, self.weights):<\/div>\n
a = sigmoid(np.dot(w, a)+b)<\/div>\n
return a<\/div>\n
defSGD(self, training_data, epochs, mini_batch_size, eta,<\/div>\n
lmbda=0.0,<\/div>\n
evaluation_data=None,<\/div>\n
monitor_evaluation_cost=False,<\/div>\n
monitor_evaluation_accuracy=False,<\/div>\n
monitor_training_cost=False,<\/div>\n
monitor_training_accuracy=False):<\/div>\n
“””Train the neural network using mini-batch stochastic gradient<\/div>\n
descent. The “training_data“ is a list of tuples “(x, y)“<\/div>\n
representing the training inputs and the desired outputs. The<\/div>\n
other non-optional parameters are self-explanatory, as is the<\/div>\n
regularization parameter “lmbda“. The method also accepts<\/div>\n
“evaluation_data“, usually either the validation or test<\/div>\n
data. We can monitor the cost and accuracy on either the<\/div>\n
evaluation data or the training data, by setting the<\/div>\n
appropriate flags. The method returns a tuple containing four<\/div>\n
lists: the (per-epoch) costs on the evaluation data, the<\/div>\n
accuracies on the evaluation data, the costs on the training<\/div>\n
data, and the accuracies on the training data. All values are<\/div>\n
evaluated at the end of each training epoch. So, for example,<\/div>\n
if we train for 30 epochs, then the first element of the tuple<\/div>\n
will be a 30-element list containing the cost on the<\/div>\n
evaluation data at the end of each epoch. Note that the lists<\/div>\n
are empty if the corresponding flag is not set.<\/div>\n
“””<\/div>\n
training_data_list = list(training_data)<\/div>\n
evaluation_data_list = list(evaluation_data)<\/div>\n
if evaluation_data:<\/div>\n
n_data = len(evaluation_data_list)<\/div>\n
n = len(training_data_list)<\/div>\n
evaluation_cost, evaluation_accuracy = [], []<\/div>\n
training_cost, training_accuracy = [], []<\/div>\n
print(“=================================================================”)<\/div>\n
print(“=================================================================”)<\/div>\n
loop = 0<\/div>\n
for j inrange(epochs):<\/div>\n
loop += 1<\/div>\n
print(“Time: “+str(time.strftime(‘%Y-%m-%d %H:%M:%S’,time.localtime(time.time()))))<\/div>\n
random.shuffle(training_data_list)<\/div>\n
training_data = training_data_list<\/div>\n
evaluation_data = evaluation_data_list<\/div>\n
mini_batches = [<\/div>\n
training_data[k:k+mini_batch_size]<\/div>\n
for k inrange(0, n, mini_batch_size)]<\/div>\n
for mini_batch in mini_batches:<\/div>\n
self.update_mini_batch(<\/div>\n
mini_batch, eta, lmbda, len(training_data))<\/div>\n
print(“Epoch %s training complete”% j)<\/div>\n
if monitor_training_cost:<\/div>\n
cost = self.total_cost(training_data, lmbda)<\/div>\n
training_cost.append(cost)<\/div>\n
print(“Cost on training data: {}”.format(cost))<\/div>\n
if monitor_training_accuracy:<\/div>\n
accuracy = self.accuracy(training_data, convert=True)<\/div>\n
training_accuracy.append(accuracy)<\/div>\n
print(“Accuracy on training data: {} \/ {}”.format(<\/div>\n
accuracy, n))<\/div>\n
if monitor_evaluation_cost:<\/div>\n
cost = self.total_cost(evaluation_data, lmbda, convert=True)<\/div>\n
evaluation_cost.append(cost)<\/div>\n
print(“Cost on evaluation data: {}”.format(cost))<\/div>\n
if monitor_evaluation_accuracy:<\/div>\n
accuracy = self.accuracy(evaluation_data)<\/div>\n
evaluation_accuracy.append(accuracy)<\/div>\n
print(“Accuracy on evaluation data: {} \/ {}”.format(<\/div>\n
self.accuracy(evaluation_data), n_data))<\/div>\n
print(“\\n”)<\/div>\n
print(“=================================================================”)<\/div>\n
print(“=================================================================”)<\/div>\n
print(” “)<\/div>\n
layer = 1<\/div>\n
print(“\u8bad\u7ec3\u540e\u7684\u6743\u91cd\u548c\u504f\u7f6e\uff1a”)<\/div>\n
for lw, lb inzip(self.weights, self.biases):<\/div>\n
layer += 1<\/div>\n
num_nw = 0<\/div>\n
for w, b inzip(lw, lb):<\/div>\n
num_nw += 1<\/div>\n
print(“\u7b2c “+str(layer)+” \u5c42\u7b2c “+str(num_nw)+” \u4e2a\u795e\u7ecf\u5143\u7684\u6743\u91cd(\u5171”+str(len(w))+”\u4e2a\u8f93\u5165)\uff1a”)<\/div>\n
print(str(w))<\/div>\n
print(“\u7b2c “+str(layer)+” \u5c42\u7b2c “+str(num_nw)+” \u4e2a\u795e\u7ecf\u5143\u7684\u504f\u7f6e(\u5171”+str(len(b))+”\u4e2a\u8f93\u51fa)\uff1a”)<\/div>\n
print(str(b))<\/div>\n
print(” “)<\/div>\n
print(” “)<\/div>\n
print(“=================================================================”)<\/div>\n
print(“=================================================================”)<\/div>\n
print(“\u6bcf\u5c42\u6d4b\u8bd5\u7ed3\u679c\u7684\u8ba1\u7b97\u516c\u5f0f\uff1a (\u8f93\u51651*\u6743\u91cd1 + \u8f93\u51652*\u6743\u91cd2 + \u8f93\u51653*\u6743\u91cd3 + …) + \u504f\u7f6e “)<\/div>\n
print(“a1*w11—|”)<\/div>\n
print(“a2*w12—|+b1—|”)<\/div>\n
print(“a3*w13—| |”)<\/div>\n
print(“……—| |-output”)<\/div>\n
print(“a1*w21—| |”)<\/div>\n
print(“a2*w22—|+b2—|”)<\/div>\n
print(“a3*w23—|”)<\/div>\n
print(“……—|”)<\/div>\n
print(“Time: “+str(time.strftime(‘%Y-%m-%d %H:%M:%S’,time.localtime(time.time()))))<\/div>\n
return evaluation_cost, evaluation_accuracy, \\<\/div>\n
training_cost, training_accuracy<\/div>\n
defupdate_mini_batch(self, mini_batch, eta, lmbda, n):<\/div>\n
“””Update the network’s weights and biases by applying gradient<\/div>\n
descent using backpropagation to a single mini batch. The<\/div>\n
“mini_batch“ is a list of tuples “(x, y)“, “eta“ is the<\/div>\n
learning rate, “lmbda“ is the regularization parameter, and<\/div>\n
“n“ is the total size of the training data set.<\/div>\n
“””<\/div>\n
nabla_b = [np.zeros(b.shape) for b in self.biases]<\/div>\n
nabla_w = [np.zeros(w.shape) for w in self.weights]<\/div>\n
for x, y in mini_batch:<\/div>\n
delta_nabla_b, delta_nabla_w = self.backprop(x, y)<\/div>\n
nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]<\/div>\n
nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]<\/div>\n
self.weights = [(1-eta*(lmbda\/n))*w-(eta\/len(mini_batch))*nw<\/div>\n
for w, nw inzip(self.weights, nabla_w)]<\/div>\n
self.biases = [b-(eta\/len(mini_batch))*nb<\/div>\n
for b, nb inzip(self.biases, nabla_b)]<\/div>\n
defbackprop(self, x, y):<\/div>\n
“””Return a tuple “(nabla_b, nabla_w)“ representing the<\/div>\n
gradient for the cost function C_x. “nabla_b“ and<\/div>\n
“nabla_w“ are layer-by-layer lists of numpy arrays, similar<\/div>\n
to “self.biases“ and “self.weights“.”””<\/div>\n
nabla_b = [np.zeros(b.shape) for b in self.biases]<\/div>\n
nabla_w = [np.zeros(w.shape) for w in self.weights]<\/div>\n
# feedforward<\/div>\n
activation = x<\/div>\n
activations = [x] # list to store all the activations, layer by layer<\/div>\n
zs = [] # list to store all the z vectors, layer by layer<\/div>\n
for b, w inzip(self.biases, self.weights):<\/div>\n
z = np.dot(w, activation)+b<\/div>\n
zs.append(z)<\/div>\n
activation = sigmoid(z)<\/div>\n
activations.append(activation)<\/div>\n
# backward pass<\/div>\n
delta = (self.cost).delta(zs[-1], activations[-1], y)<\/div>\n
nabla_b[-1] = delta<\/div>\n
nabla_w[-1] = np.dot(delta, activations[-2].transpose())<\/div>\n
# Note that the variable l in the loop below is used a little<\/div>\n
# differently to the notation in Chapter 2 of the book. Here,<\/div>\n
# l = 1 means the last layer of neurons, l = 2 is the<\/div>\n
# second-last layer, and so on. It’s a renumbering of the<\/div>\n
# scheme in the book, used here to take advantage of the fact<\/div>\n
# that Python can use negative indices in lists.<\/div>\n
for l inrange(2, self.num_layers):<\/div>\n
z = zs[-l]<\/div>\n
sp = sigmoid_prime(z)<\/div>\n
delta = np.dot(self.weights[-l+1].transpose(), delta) * sp<\/div>\n
nabla_b[-l] = delta<\/div>\n
nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())<\/div>\n
return (nabla_b, nabla_w)<\/div>\n
defaccuracy(self, data, convert=False):<\/div>\n
“””Return the number of inputs in “data“ for which the neural<\/div>\n
network outputs the correct result. The neural network’s<\/div>\n
output is assumed to be the index of whichever neuron in the<\/div>\n
final layer has the highest activation.<\/div>\n
The flag “convert“ should be set to False if the data set is<\/div>\n
validation or test data (the usual case), and to True if the<\/div>\n
data set is the training data. The need for this flag arises<\/div>\n
due to differences in the way the results “y“ are<\/div>\n
represented in the different data sets. In particular, it<\/div>\n
flags whether we need to convert between the different<\/div>\n
representations. It may seem strange to use different<\/div>\n
representations for the different data sets. Why not use the<\/div>\n
same representation for all three data sets? It’s done for<\/div>\n
efficiency reasons — the program usually evaluates the cost<\/div>\n
on the training data and the accuracy on other data sets.<\/div>\n
These are different types of computations, and using different<\/div>\n
representations speeds things up. More details on the<\/div>\n
representations can be found in<\/div>\n
mnist_loader.load_data_wrapper.<\/div>\n
“””<\/div>\n
if convert:<\/div>\n
results = [(np.argmax(self.feedforward(x)), np.argmax(y))<\/div>\n
for (x, y) in data]<\/div>\n
else:<\/div>\n
results = [(np.argmax(self.feedforward(x)), y)<\/div>\n
for (x, y) in data]<\/div>\n
returnsum(int(x == y) for (x, y) in results)<\/div>\n
deftotal_cost(self, data, lmbda, convert=False):<\/div>\n
“””Return the total cost for the data set “data“. The flag<\/div>\n
“convert“ should be set to False if the data set is the<\/div>\n
training data (the usual case), and to True if the data set is<\/div>\n
the validation or test data. See comments on the similar (but<\/div>\n
reversed) convention for the “accuracy“ method, above.<\/div>\n
“””<\/div>\n
data_list = list(data)<\/div>\n
cost = 0.0<\/div>\n
for x, y in data:<\/div>\n
a = self.feedforward(x)<\/div>\n
if convert: y = vectorized_result(y)<\/div>\n
cost += self.cost.fn(a, y)\/len(data_list)<\/div>\n
cost += 0.5*(lmbda\/len(data_list))*sum(<\/div>\n
np.linalg.norm(w)**2 for w in self.weights)<\/div>\n
return cost<\/div>\n
defsave(self, filename):<\/div>\n
“””Save the neural network to the file “filename“.”””<\/div>\n
data = {“sizes”: self.sizes,<\/div>\n
“weights”: [w.tolist() for w inself.weights],<\/div>\n
“biases”: [b.tolist() for b inself.biases],<\/div>\n
“cost”: str(self.cost.__name__)}<\/div>\n
f = open(filename, “w”)<\/div>\n
json.dump(data, f)<\/div>\n
f.close()<\/div>\n
#### Loading a Network<\/div>\n
def load(filename):<\/div>\n
“””Load a neural network from the file “filename“. Returns an<\/div>\n
instance of Network.<\/div>\n
“””<\/div>\n
f = open(filename, “r”)<\/div>\n
data = json.load(f)<\/div>\n
f.close()<\/div>\n
cost = getattr(sys.modules[__name__], data[“cost”])<\/div>\n
net = Network(data[“sizes”], cost=cost)<\/div>\n
net.weights = [np.array(w) for w in data[“weights”]]<\/div>\n
net.biases = [np.array(b) for b in data[“biases”]]<\/div>\n
return net<\/div>\n
#### Miscellaneous functions<\/div>\n
def vectorized_result(j):<\/div>\n
“””Return a 10-dimensional unit vector with a 1.0 in the j’th position<\/div>\n
and zeroes elsewhere. This is used to convert a digit (0…9)<\/div>\n
into a corresponding desired output from the neural network.<\/div>\n
“””<\/div>\n
e = np.zeros((10, 1))<\/div>\n
e[j] = 1.0<\/div>\n
return e<\/div>\n
def sigmoid(z):<\/div>\n
“””The sigmoid function.”””<\/div>\n
return1.0\/(1.0+np.exp(-z))<\/div>\n
def sigmoid_prime(z):<\/div>\n
“””Derivative of the sigmoid function.”””<\/div>\n
return sigmoid(z)*(1-sigmoid(z))<\/div>\n
def test():<\/div>\n
import mnist_loader<\/div>\n
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()<\/div>\n
# net = Network([784, 30, 10], cost=QuadraticCost)<\/div>\n
net = Network([784, 30, 10], cost=CrossEntropyCost)<\/div>\n
# net.large_weight_initializer()<\/div>\n
net.default_weight_initializer()<\/div>\n
net.print_init_bias_weight()<\/div>\n
# net.SGD(training_data, 30, 10, 0.5, evaluation_data=test_data,<\/div>\n
net.SGD(training_data, 5, 10, 0.5, evaluation_data=test_data,<\/div>\n
monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True)<\/div>\n
net.save(“network2_save.dat”)<\/div>\n
# \u5982\u679c\u505c\u6b62\u4e86\uff0c\u8981\u63a5\u7740\u518d\u8bad\u7ec3<\/div>\n
print(“######################################################################################################”)<\/div>\n
print(“########################################## \u65b0\u7684\u4e00\u8f6e\u6d4b\u8bd5\uff1a##############################################”)<\/div>\n
time.sleep(3)<\/div>\n
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()<\/div>\n
net = load(“network2_save.dat”)<\/div>\n
# net.default_weight_initializer() #\u4e0d\u8981\u518d\u521d\u59cb\u5316\u4e86<\/div>\n
net.print_init_bias_weight()<\/div>\n
net.SGD(training_data, 5, 10, 0.5, evaluation_data=test_data,<\/div>\n
monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True)<\/div>\n
net.save(“network2_save.dat”)<\/div>\n
if __name__ == ‘__main__’:<\/div>\n
test()<\/div>\n<\/div>\n

 <\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

\u300a\u795e\u7ecf\u7f51\u7edc\u4e0e\u6df1\u5ea6\u5b66\u4e60\u300b\uff08Michael Nielsen\u8457\uff09\u4e2d\u7684\u4ee3\u7801\u662f\u57fa\u4e8epython2.7\u7684\uff0c\u4e0b\u9762\u4e3a\u79fb\u690d\u5230py …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[443],"tags":[727,108,446,447],"class_list":["post-986","post","type-post","status-publish","format-standard","hentry","category-443","tag-network2","tag-python","tag-446","tag-447"],"views":2446,"_links":{"self":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/986","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=986"}],"version-history":[{"count":1,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/986\/revisions"}],"predecessor-version":[{"id":988,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/986\/revisions\/988"}],"wp:attachment":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=986"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=986"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=986"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}