{"id":989,"date":"2019-01-22T10:55:17","date_gmt":"2019-01-22T02:55:17","guid":{"rendered":"http:\/\/www.max-shu.com\/blog\/?p=989"},"modified":"2019-01-22T10:57:00","modified_gmt":"2019-01-22T02:57:00","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%81network3-py","status":"publish","type":"post","link":"http:\/\/www.max-shu.com\/blog\/?p=989","title":{"rendered":"\u300a\u795e\u7ecf\u7f51\u7edc\u4e0e\u6df1\u5ea6\u5b66\u4e60\u300b\u4e2d\u7684Python 3.x \u4ee3\u7801network3.py"},"content":{"rendered":"
\n
\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<\/div>\n<\/header>\n
\n

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

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

 <\/p>\n

\n
“””expand_mnist.py<\/div>\n
~~~~~~~~~~~~~~~~~~<\/div>\n
Take the 50,000 MNIST training images, and create an expanded set of<\/div>\n
250,000 images, by displacing each training image up, down, left and<\/div>\n
right, by one pixel. Save the resulting file to<\/div>\n
..\/data\/mnist_expanded.pkl.gz.<\/div>\n
Note that this program is memory intensive, and may not run on small<\/div>\n
systems.<\/div>\n
“””<\/div>\n
from __future__ import print_function<\/div>\n
#### Libraries<\/div>\n
# Standard library<\/div>\n
import _pickle as cPickle<\/div>\n
# import cPickle<\/div>\n
import gzip<\/div>\n
import os.path<\/div>\n
import random<\/div>\n
# Third-party libraries<\/div>\n
import numpy as np<\/div>\n
print(“Expanding the MNIST training set”)<\/div>\n
if os.path.exists(“.\/mnist_expanded.pkl.gz”):<\/div>\n
print(“The expanded training set already exists. Exiting.”)<\/div>\n
else:<\/div>\n
f = gzip.open(“.\/mnist.pkl.gz”, ‘rb’)<\/div>\n
training_data, validation_data, test_data = cPickle.load(f, encoding=’iso-8859-1′)<\/div>\n
f.close()<\/div>\n
expanded_training_pairs = []<\/div>\n
j = 0 # counter<\/div>\n
for x, y inzip(training_data[0], training_data[1]):<\/div>\n
expanded_training_pairs.append((x, y))<\/div>\n
image = np.reshape(x, (-1, 28))<\/div>\n
j += 1<\/div>\n
if j %1000==0: print(“Expanding image number”, j)<\/div>\n
# iterate over data telling us the details of how to<\/div>\n
# do the displacement<\/div>\n
for d, axis, index_position, index in [<\/div>\n
(1, 0, “first”, 0),<\/div>\n
(-1, 0, “first”, 27),<\/div>\n
(1, 1, “last”, 0),<\/div>\n
(-1, 1, “last”, 27)]:<\/div>\n
new_img = np.roll(image, d, axis)<\/div>\n
if index_position ==”first”:<\/div>\n
new_img[index, :] = np.zeros(28)<\/div>\n
else:<\/div>\n
new_img[:, index] = np.zeros(28)<\/div>\n
expanded_training_pairs.append((np.reshape(new_img, 784), y))<\/div>\n
random.shuffle(expanded_training_pairs)<\/div>\n
expanded_training_data = [list(d) for d in zip(*expanded_training_pairs)]<\/div>\n
print(“Saving expanded data. This may take a few minutes.”)<\/div>\n
f = gzip.open(“.\/mnist_expanded.pkl.gz”, “w”)<\/div>\n
cPickle.dump((expanded_training_data, validation_data, test_data), f)<\/div>\n
f.close()<\/div>\n<\/div>\n

 <\/p>\n

\n

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

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

 <\/p>\n

\n
“””network3.py<\/div>\n
~~~~~~~~~~~~~~<\/div>\n
A Theano-based program for training and running simple neural<\/div>\n
networks.<\/div>\n
Supports several layer types (fully connected, convolutional, max<\/div>\n
pooling, softmax), and activation functions (sigmoid, tanh, and<\/div>\n
rectified linear units, with more easily added).<\/div>\n
When run on a CPU, this program is much faster than network.py and<\/div>\n
network2.py. However, unlike network.py and network2.py it can also<\/div>\n
be run on a GPU, which makes it faster still.<\/div>\n
Because the code is based on Theano, the code is different in many<\/div>\n
ways from network.py and network2.py. However, where possible I have<\/div>\n
tried to maintain consistency with the earlier programs. In<\/div>\n
particular, the API is similar to network2.py. Note that I have<\/div>\n
focused on making the code simple, easily readable, and easily<\/div>\n
modifiable. It is not optimized, and omits many desirable features.<\/div>\n
This program incorporates ideas from the Theano documentation on<\/div>\n
convolutional neural nets (notably,<\/div>\n
http:\/\/deeplearning.net\/tutorial\/lenet.html ), from Misha Denil’s<\/div>\n
implementation of dropout (https:\/\/github.com\/mdenil\/dropout ), and<\/div>\n
from Chris Olah (http:\/\/colah.github.io ).<\/div>\n
Written for Theano 0.6 and 0.7, needs some changes for more recent<\/div>\n
versions of Theano.<\/div>\n
“””<\/div>\n
#### Libraries<\/div>\n
# Standard library<\/div>\n
import _pickle as cPickle<\/div>\n
# import cPickle<\/div>\n
import gzip<\/div>\n
# Third-party libraries<\/div>\n
import numpy as np<\/div>\n
import theano<\/div>\n
import theano.tensor as T<\/div>\n
from theano.tensor.nnet import conv<\/div>\n
from theano.tensor.nnet import softmax<\/div>\n
from theano.tensor import shared_randomstreams<\/div>\n
from theano.tensor.signal.pool import pool_2d<\/div>\n
# from theano.tensor.signal import downsample<\/div>\n
# Activation functions for neurons<\/div>\n
def linear(z): return z<\/div>\n
def ReLU(z): return T.maximum(0.0, z)<\/div>\n
from theano.tensor.nnet import sigmoid<\/div>\n
from theano.tensor import tanh<\/div>\n
#### Constants<\/div>\n
GPU = True<\/div>\n
if GPU:<\/div>\n
print(“Trying to run under a GPU. If this is not desired, then modify “+\\<\/div>\n
“network3.py\\nto set the GPU flag to False.”)<\/div>\n
try: theano.config.device =’gpu’<\/div>\n
except: pass# it’s already set<\/div>\n
theano.config.floatX = ‘float32’<\/div>\n
else:<\/div>\n
print(“Running with a CPU. If this is not desired, then the modify “+\\<\/div>\n
“network3.py to set\\nthe GPU flag to True.”)<\/div>\n
#### Load the MNIST data<\/div>\n
def load_data_shared(filename=”.\/mnist.pkl.gz”):<\/div>\n
f = gzip.open(filename, ‘rb’)<\/div>\n
training_data, validation_data, test_data = cPickle.load(f, encoding=’iso-8859-1′)<\/div>\n
f.close()<\/div>\n
# \u51cf\u5c11\u6570\u636e\u91cf\uff0c\u4ee5\u4fbf\u6d4b\u8bd5\u65f6\u4e34\u65f6\u5feb\u901f\u89c2\u5bdf\u6d41\u7a0b\u3002<\/div>\n
RealCount = 20<\/div>\n
temp_data = []<\/div>\n
count = 0<\/div>\n
for x, y inzip(training_data[0], training_data[1]):<\/div>\n
temp_data.append((x, y))<\/div>\n
count += 1<\/div>\n
if count >= RealCount :<\/div>\n
break<\/div>\n
training_data = [list(d) for d in zip(*temp_data)]<\/div>\n
temp_data = []<\/div>\n
count = 0<\/div>\n
for x, y inzip(validation_data[0], validation_data[1]):<\/div>\n
temp_data.append((x, y))<\/div>\n
count += 1<\/div>\n
if count >= RealCount :<\/div>\n
break<\/div>\n
validation_data = [list(d) for d in zip(*temp_data)]<\/div>\n
temp_data = []<\/div>\n
count = 0<\/div>\n
for x, y inzip(test_data[0], test_data[1]):<\/div>\n
temp_data.append((x, y))<\/div>\n
count += 1<\/div>\n
if count >= RealCount :<\/div>\n
break<\/div>\n
test_data = [list(d) for d in zip(*temp_data)]<\/div>\n
defshared(data):<\/div>\n
“””Place the data into shared variables. This allows Theano to copy<\/div>\n
the data to the GPU, if one is available.<\/div>\n
“””<\/div>\n
shared_x = theano.shared(<\/div>\n
np.asarray(data[0], dtype=theano.config.floatX), borrow=True)<\/div>\n
shared_y = theano.shared(<\/div>\n
np.asarray(data[1], dtype=theano.config.floatX), borrow=True)<\/div>\n
return shared_x, T.cast(shared_y, “int32”)<\/div>\n
return [shared(training_data), shared(validation_data), shared(test_data)]<\/div>\n
#### Main class used to construct and train networks<\/div>\n
class Network(object):<\/div>\n
def__init__(self, layers, mini_batch_size):<\/div>\n
“””Takes a list of `layers`, describing the network architecture, and<\/div>\n
a value for the `mini_batch_size` to be used during training<\/div>\n
by stochastic gradient descent.<\/div>\n
“””<\/div>\n
self.layers = layers<\/div>\n
self.mini_batch_size = mini_batch_size<\/div>\n
self.params = [param for layer inself.layers for param in layer.params]<\/div>\n
self.x = T.matrix(“x”)<\/div>\n
self.y = T.ivector(“y”)<\/div>\n
init_layer = self.layers[0]<\/div>\n
init_layer.set_inpt(self.x, self.x, self.mini_batch_size)<\/div>\n
for j inrange(1, len(self.layers)):<\/div>\n
prev_layer, layer = self.layers[j-1], self.layers[j]<\/div>\n
layer.set_inpt(<\/div>\n
prev_layer.output, prev_layer.output_dropout, self.mini_batch_size)<\/div>\n
self.output =self.layers[-1].output<\/div>\n
self.output_dropout =self.layers[-1].output_dropout<\/div>\n
defSGD(self, training_data, epochs, mini_batch_size, eta,<\/div>\n
validation_data, test_data, lmbda=0.0):<\/div>\n
“””Train the network using mini-batch stochastic gradient descent.”””<\/div>\n
training_x, training_y = training_data<\/div>\n
validation_x, validation_y = validation_data<\/div>\n
test_x, test_y = test_data<\/div>\n
# compute number of minibatches for training, validation and testing<\/div>\n
num_training_batches = int(size(training_data)\/mini_batch_size)<\/div>\n
num_validation_batches = int(size(validation_data)\/mini_batch_size)<\/div>\n
num_test_batches = int(size(test_data)\/mini_batch_size)<\/div>\n
# define the (regularized) cost function, symbolic gradients, and updates<\/div>\n
l2_norm_squared = sum([(layer.w**2).sum() for layer in self.layers])<\/div>\n
cost = self.layers[-1].cost(self)+\\<\/div>\n
0.5*lmbda*l2_norm_squared\/num_training_batches<\/div>\n
grads = T.grad(cost, self.params)<\/div>\n
updates = [(param, param-eta*grad)<\/div>\n
for param, grad inzip(self.params, grads)]<\/div>\n
# define functions to train a mini-batch, and to compute the<\/div>\n
# accuracy in validation and test mini-batches.<\/div>\n
i = T.lscalar() # mini-batch index<\/div>\n
train_mb = theano.function(<\/div>\n
[i], cost, updates=updates,<\/div>\n
givens={<\/div>\n
self.x:<\/div>\n
training_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size],<\/div>\n
self.y:<\/div>\n
training_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]<\/div>\n
})<\/div>\n
validate_mb_accuracy = theano.function(<\/div>\n
[i], self.layers[-1].accuracy(self.y),<\/div>\n
givens={<\/div>\n
self.x:<\/div>\n
validation_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size],<\/div>\n
self.y:<\/div>\n
validation_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]<\/div>\n
})<\/div>\n
test_mb_accuracy = theano.function(<\/div>\n
[i], self.layers[-1].accuracy(self.y),<\/div>\n
givens={<\/div>\n
self.x:<\/div>\n
test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size],<\/div>\n
self.y:<\/div>\n
test_y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]<\/div>\n
})<\/div>\n
self.test_mb_predictions = theano.function(<\/div>\n
[i], self.layers[-1].y_out,<\/div>\n
givens={<\/div>\n
self.x:<\/div>\n
test_x[i*self.mini_batch_size: (i+1)*self.mini_batch_size]<\/div>\n
})<\/div>\n
# Do the actual training<\/div>\n
best_validation_accuracy = 0.0<\/div>\n
for epoch inrange(epochs):<\/div>\n
for minibatch_index inrange(num_training_batches):<\/div>\n
iteration = num_training_batches*epoch+minibatch_index<\/div>\n
# if iteration % 1000 == 0:<\/div>\n
if iteration %10==0:<\/div>\n
print(“Training mini-batch number {0}”.format(iteration))<\/div>\n
cost_ij = train_mb(minibatch_index)<\/div>\n
if (iteration+1) % num_training_batches ==0:<\/div>\n
validation_accuracy = np.mean(<\/div>\n
[validate_mb_accuracy(j) for j in range(num_validation_batches)])<\/div>\n
print(“Epoch {0}: validation accuracy {1:.2%}”.format(<\/div>\n
epoch, validation_accuracy))<\/div>\n
if validation_accuracy >= best_validation_accuracy:<\/div>\n
print(“This is the best validation accuracy to date.”)<\/div>\n
best_validation_accuracy = validation_accuracy<\/div>\n
best_iteration = iteration<\/div>\n
if test_data:<\/div>\n
test_accuracy = np.mean(<\/div>\n
[test_mb_accuracy(j) for j in range(num_test_batches)])<\/div>\n
print(‘The corresponding test accuracy is {0:.2%}’.format(<\/div>\n
test_accuracy))<\/div>\n
print(“Finished training network.”)<\/div>\n
print(“Best validation accuracy of {0:.2%} obtained at iteration {1}”.format(<\/div>\n
best_validation_accuracy, best_iteration))<\/div>\n
print(“Corresponding test accuracy of {0:.2%}”.format(test_accuracy))<\/div>\n
#### Define layer types<\/div>\n
class ConvPoolLayer(object):<\/div>\n
“””Used to create a combination of a convolutional and a max-pooling<\/div>\n
layer. A more sophisticated implementation would separate the<\/div>\n
two, but for our purposes we’ll always use them together, and it<\/div>\n
simplifies the code, so it makes sense to combine them.<\/div>\n
“””<\/div>\n
def__init__(self, filter_shape, image_shape, poolsize=(2, 2),<\/div>\n
activation_fn=sigmoid):<\/div>\n
“””`filter_shape` is a tuple of length 4, whose entries are the number<\/div>\n
of filters, the number of input feature maps, the filter height, and the<\/div>\n
filter width.<\/div>\n
`image_shape` is a tuple of length 4, whose entries are the<\/div>\n
mini-batch size, the number of input feature maps, the image<\/div>\n
height, and the image width.<\/div>\n
`poolsize` is a tuple of length 2, whose entries are the y and<\/div>\n
x pooling sizes.<\/div>\n
“””<\/div>\n
self.filter_shape = filter_shape<\/div>\n
self.image_shape = image_shape<\/div>\n
self.poolsize = poolsize<\/div>\n
self.activation_fn=activation_fn<\/div>\n
# initialize weights and biases<\/div>\n
n_out = (filter_shape[0]*np.prod(filter_shape[2:])\/np.prod(poolsize))<\/div>\n
self.w = theano.shared(<\/div>\n
np.asarray(<\/div>\n
np.random.normal(loc=0, scale=np.sqrt(1.0\/n_out), size=filter_shape),<\/div>\n
dtype=theano.config.floatX),<\/div>\n
borrow=True)<\/div>\n
self.b = theano.shared(<\/div>\n
np.asarray(<\/div>\n
np.random.normal(loc=0, scale=1.0, size=(filter_shape[0],)),<\/div>\n
dtype=theano.config.floatX),<\/div>\n
borrow=True)<\/div>\n
self.params = [self.w, self.b]<\/div>\n
defset_inpt(self, inpt, inpt_dropout, mini_batch_size):<\/div>\n
self.inpt = inpt.reshape(self.image_shape)<\/div>\n
conv_out = conv.conv2d(<\/div>\n
input=self.inpt, filters=self.w, filter_shape=self.filter_shape,<\/div>\n
image_shape=self.image_shape)<\/div>\n
# pooled_out = downsample.max_pool_2d(<\/div>\n
# input=conv_out, ds=self.poolsize, ignore_border=True)<\/div>\n
pooled_out = pool_2d(<\/div>\n
input=conv_out, ds=self.poolsize, ignore_border=True)<\/div>\n
self.output =self.activation_fn(<\/div>\n
pooled_out + self.b.dimshuffle(‘x’, 0, ‘x’, ‘x’))<\/div>\n
self.output_dropout =self.output # no dropout in the convolutional layers<\/div>\n
class FullyConnectedLayer(object):<\/div>\n
def__init__(self, n_in, n_out, activation_fn=sigmoid, p_dropout=0.0):<\/div>\n
self.n_in = n_in<\/div>\n
self.n_out = n_out<\/div>\n
self.activation_fn = activation_fn<\/div>\n
self.p_dropout = p_dropout<\/div>\n
# Initialize weights and biases<\/div>\n
self.w = theano.shared(<\/div>\n
np.asarray(<\/div>\n
np.random.normal(<\/div>\n
loc=0.0, scale=np.sqrt(1.0\/n_out), size=(n_in, n_out)),<\/div>\n
dtype=theano.config.floatX),<\/div>\n
name=’w’, borrow=True)<\/div>\n
self.b = theano.shared(<\/div>\n
np.asarray(np.random.normal(loc=0.0, scale=1.0, size=(n_out,)),<\/div>\n
dtype=theano.config.floatX),<\/div>\n
name=’b’, borrow=True)<\/div>\n
self.params = [self.w, self.b]<\/div>\n
defset_inpt(self, inpt, inpt_dropout, mini_batch_size):<\/div>\n
self.inpt = inpt.reshape((mini_batch_size, self.n_in))<\/div>\n
self.output =self.activation_fn(<\/div>\n
(1-self.p_dropout)*T.dot(self.inpt, self.w) + self.b)<\/div>\n
self.y_out = T.argmax(self.output, axis=1)<\/div>\n
self.inpt_dropout = dropout_layer(<\/div>\n
inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout)<\/div>\n
self.output_dropout =self.activation_fn(<\/div>\n
T.dot(self.inpt_dropout, self.w) + self.b)<\/div>\n
defaccuracy(self, y):<\/div>\n
“Return the accuracy for the mini-batch.”<\/div>\n
return T.mean(T.eq(y, self.y_out))<\/div>\n
class SoftmaxLayer(object):<\/div>\n
def__init__(self, n_in, n_out, p_dropout=0.0):<\/div>\n
self.n_in = n_in<\/div>\n
self.n_out = n_out<\/div>\n
self.p_dropout = p_dropout<\/div>\n
# Initialize weights and biases<\/div>\n
self.w = theano.shared(<\/div>\n
np.zeros((n_in, n_out), dtype=theano.config.floatX),<\/div>\n
name=’w’, borrow=True)<\/div>\n
self.b = theano.shared(<\/div>\n
np.zeros((n_out,), dtype=theano.config.floatX),<\/div>\n
name=’b’, borrow=True)<\/div>\n
self.params = [self.w, self.b]<\/div>\n
defset_inpt(self, inpt, inpt_dropout, mini_batch_size):<\/div>\n
self.inpt = inpt.reshape((mini_batch_size, self.n_in))<\/div>\n
self.output = softmax((1-self.p_dropout)*T.dot(self.inpt, self.w) +self.b)<\/div>\n
self.y_out = T.argmax(self.output, axis=1)<\/div>\n
self.inpt_dropout = dropout_layer(<\/div>\n
inpt_dropout.reshape((mini_batch_size, self.n_in)), self.p_dropout)<\/div>\n
self.output_dropout = softmax(T.dot(self.inpt_dropout, self.w) +self.b)<\/div>\n
defcost(self, net):<\/div>\n
“Return the log-likelihood cost.”<\/div>\n
return-T.mean(T.log(self.output_dropout)[T.arange(net.y.shape[0]), net.y])<\/div>\n
defaccuracy(self, y):<\/div>\n
“Return the accuracy for the mini-batch.”<\/div>\n
return T.mean(T.eq(y, self.y_out))<\/div>\n
#### Miscellanea<\/div>\n
def size(data):<\/div>\n
“Return the size of the dataset `data`.”<\/div>\n
return data[0].get_value(borrow=True).shape[0]<\/div>\n
def dropout_layer(layer, p_dropout):<\/div>\n
srng = shared_randomstreams.RandomStreams(<\/div>\n
np.random.RandomState(0).randint(999999))<\/div>\n
mask = srng.binomial(n=1, p=1-p_dropout, size=layer.shape)<\/div>\n
return layer*T.cast(mask, theano.config.floatX)<\/div>\n
def test():<\/div>\n
# expanded_training_data, _, _ = load_data_shared(“.\/mnist_expanded.pkl.gz”)<\/div>\n
training_data, validation_data, test_data = load_data_shared()<\/div>\n
mini_batch_size = 10<\/div>\n
net = Network( [<\/div>\n
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2), activation_fn=ReLU),<\/div>\n
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2), activation_fn=ReLU),<\/div>\n
FullyConnectedLayer(n_in=40*4*4, n_out=1000, activation_fn=ReLU, p_dropout=0.5),<\/div>\n
FullyConnectedLayer(n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=0.5),<\/div>\n
SoftmaxLayer(n_in=1000, n_out=10, p_dropout=0.5)<\/div>\n
], mini_batch_size)<\/div>\n
# net.SGD(expanded_training_data, 40, mini_batch_size, 0.03, validation_data, test_data)<\/div>\n
# net.SGD(expanded_training_data, 3, mini_batch_size, 0.03, validation_data, test_data)<\/div>\n
net.SGD(training_data, 3, mini_batch_size, 0.03, validation_data, test_data)<\/div>\n
if __name__ == ‘__main__’:<\/div>\n
test()<\/div>\n<\/div>\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":[728,108,446,447],"class_list":["post-989","post","type-post","status-publish","format-standard","hentry","category-443","tag-network3","tag-python","tag-446","tag-447"],"views":1936,"_links":{"self":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/989","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=989"}],"version-history":[{"count":3,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/989\/revisions"}],"predecessor-version":[{"id":994,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/989\/revisions\/994"}],"wp:attachment":[{"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=989"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=989"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.max-shu.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=989"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}