# 自然语言处理（NLP）——LSTM网络

使用全连接神经网络来处理自然语言未免有些乏力，之前也可以看出准确率并不是很高，这时候就需要另一种专为NLP而生的网络——LSTM网络（长短时记忆网络）。

想要学习这个网络，得先从RNN看起。循环神经网络（Recurrent Neural Network，RNN）是一种用于处理序列数据的神经网络。相比一般的神经网络来说，他能够处理序列变化的数据。它的激活函数多采用双曲正切函数tanh而不是relu，当然也可以使用relu。而为了每一步操作的统一性，在第一步时会手动添加一个共同输入a0，比如一个全0向量。

而完全体的LSTM是比较复杂的


![屏幕截图 2022-01-09 154012.png](https://www.chinfo.top/static/img/1a02790465b5d256ab16d266c5511399.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-09%20154012.png)

首先LSTM结构中的输出再次经过一个tanh函数，而原先的输出，就变成了一个叫做细胞状态（Ct）的东西，这个细胞状态就是LSTM能应对长依赖问题的关键，它就能让网络具有记忆和遗忘的效果。为了实现这个效果，LSTM使用了两个门来实现。第一个是遗忘门（forget gate）。使用一个sigmoid层，使其与上个细胞状态值相乘。当sigmoid为0时，就相当于把上个细胞值完全丢弃，即忘记。反之则全部记忆。而这个sigmoid层的输入则是本次词向量与上一次的输出合并的数据，这样就可以通过本次与之前的数据共同决定忘记多少之前的细胞值。第二个是更新门（update gate）。让本次的词向量与上一此的输出合并的数据在经过一个sigmoid层形成控制这个在之前标准RNN结构中用来更新的部分，即用来控制是否更新本次细胞状态值。这样就实现了记忆和遗忘的效果。而最后还有一个输出门，在标准RNN结构最后的输出也乘一个sigmoid层，这样在遇到重要词汇时产生强输出，使其难以遗忘，反之亦然。

当然这只是对LSTM的及其粗略的讲解，这篇博客有着更加详细的讲解，还有LSTM变种结构比如GRU的介绍。

https://colah.github.io/posts/2015-08-Understanding-LSTMs/

之后就是利用LSTM对之前的网购评论数据进行学习了。

我在GitHub上找到了一个训练好的中文词向量

https://github.com/Embedding/Chinese-Word-Vectors

利用这个词向量来训练LSTM网络

首先封装一个能读取这个词向量文件的chinese_vec.py

```
import os
import numpy as np
def load_word_vecs():
	embeddings_index = {}
	f = open(os.path.dirname(os.path.abspath(__file__))+'/sgns.target.word-word.dynwin5.thr10.neg5.dim300.iter5',encoding='utf8')
	f.readline()#escape first line
	for line in f:
	    values = line.split()
	    word = values[0]
	    coefs = np.asarray(values[1:], dtype='float32')
	    embeddings_index[word] = coefs
	f.close()

	print('Found %s word vectors.' % len(embeddings_index))
	return embeddings_index
```

然后调用它读取，在经过判断是否存在后写入一个空数组。

```
word_vecs = chinese_vec.load_word_vecs()
embedding_matrix = np.zeros((vocalen, 300))

for word, i in word_index.items():
	embedding_vector = word_vecs.get(word)
	if embedding_vector is not None:
		embedding_matrix[i] = embedding_vector
```

然后就是构造LSTM，使用Keras可以十分简单

```
model = Sequential()
model.add(Embedding(trainable=False, weights=[embedding_matrix], input_dim=vocalen, output_dim=300, input_length=maxlen))
model.add(LSTM(128, return_sequences=True))
model.add(LSTM(128))
```

之后就可以开始训练了。最后可以得到一个接近90%的准确率


![屏幕截图 2022-01-09 160735.png](https://www.chinfo.top/static/img/7f57e0b9b2d3c3995f4c4323e8ca3df6.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-09%20160735.png)

自然语言处理（NLP）——LSTM网络

# 深度学习与卷积神经网络

## 深度学习

深度学习，就是不断增加一个神经网络的隐藏层神经元，让输入的数据被这些神经元不断地抽象和理解，最后得到一个具有泛化能力的预测网络模型。而我们一般把隐藏层超过三层的神经网络称为“深度神经网络”。

我们很难用精确的数学手段去分析网络中的每一个神经元在想什么，我们能做的也就只有对学习率，激活函数，神经元数量等等方面进行更改，并送入数据进行训练，期待最后的结果。

想直观的体验这样的过程tensorflow游乐场是个很好的网站（https://playground.tensorflow.org）

接下来，我就使用Keras来实现一个简单的深度学习。

这次的散点图就变得更加复杂。


![屏幕截图 2022-01-07 094014.png](https://www.chinfo.top/static/img/c63e0f00f94b1f45f3062aefc2c107b5.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-07%20094014.png)



上下螺旋型的分布使得之前写过的所有模型都不再适合，这时候Keras的强大与便捷便体现了出来。只需要调一调参数，增加隐藏层数量，一个更加强的深度神经网络便形成了。

```
import dataset
import numpy as np
import plot_utils
from keras.models import Sequential 
from keras.layers import Dense 
from tensorflow.keras.optimizers import SGD

m = 100
X, Y = dataset.get_beans(m)
plot_utils.show_scatter(X,Y)

model = Sequential()
model.add(Dense(units=8, activation='relu', input_dim=2))
model.add(Dense(units=8, activation='relu',))
model.add(Dense(units=8, activation='relu',))
model.add(Dense(units=1, activation='sigmoid',))

model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])

model.fit(X, Y, epochs=5000, batch_size=10)

pres = model.predict(X)

plot_utils.show_scatter_surface(X, Y, model)
```

甚至不需要太多代码就能很好的拟合


![屏幕截图 2022-01-06 161953.png](https://www.chinfo.top/static/img/6fd293a83d963dfa2bfcce266e02621f.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-06%20161953.png)

## 卷积神经网络

在机器学习，神经网络领域，有一个应用层面上的经典的“hello world”。那就是手写体识别。因为它场景简单明确，更有经典的数据集mnist。

mnist数据集里是28*28像素的灰度图，用0到255来代表颜色的深浅。我们要怎样将一张图片送入神经网络进行学习呢？没错，我们把这些像素看成数字就好，这将形成一个最小值为0，最大值为255的(28,28)的矩阵，自然就可以送入学习了。

但是，如果使用全连接神经网络，即使把网络堆叠的越来越深，添加更多的隐藏层，用尽防止过拟合的方法，但泛化能力依旧不尽人意。在深度学习巨头Lecun整理的数据中，效果最好的全连接神经网络是2010年的一个6层的网络，规模已经达到了惊人的2500-2000-1500-1000-500-10，作者也毫不避讳的说到，他们就是硬算，他们有强大的显卡。

但对于卷积神经网络，即使是早在1998年提出的LeNet-5也比6层的全连接神经网络准确率更高。接下来我就用mnist数据集复现一下这个经典的卷积神经网络。

为了体现卷积神经网络的优势，我先用全连接神经网络搭建了一个模型。

```
from keras.datasets import mnist
import numpy as np
from keras.models import Sequential 
from keras.layers import Dense 
from tensorflow.keras.optimizers import SGD
import matplotlib.pyplot as plt
from tensorflow.keras.utils import to_categorical

(X_train, Y_train), (X_test, Y_test) = mnist.load_data() #均为numpy的ndarray类型

print("X_train.shape:"+str(X_train.shape))
print("Y_train.shape:"+str(Y_train.shape))
print("X_test.shape:"+str(X_test.shape))
print("Y_test.shape:"+str(Y_test.shape))

print(Y_train[0])
plt.imshow(X_train[0], cmap='gray')
plt.show()

X_train = X_train.reshape(60000,784)/255.0
X_test = X_test.reshape(10000,784)/255.0

Y_train = to_categorical(Y_train,10)
Y_test = to_categorical(Y_test,10)

model = Sequential()
model.add(Dense(units=256, activation='relu', input_dim=784))
model.add(Dense(units=256, activation='relu',))
model.add(Dense(units=256, activation='relu',))
model.add(Dense(units=10, activation='softmax',))

model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])

model.fit(X_train, Y_train, epochs=5000, batch_size=2048)

pres = model.predict(X)

plot_utils.show_scatter_surface(X, Y, model)
```

这是一个256-256-256-10的模型。因为使用的是全连接层，所以我使用reshape()函数将60000*28*28和10000*28*28改成了60000*784和10000*784。又在 X_train 和 X_test 的值后/255进行归一化操作，将激活函数改为了更加适合多分类的softmax。运行得到的结果是这样的：

![屏幕截图 2022-01-08 153810](C:\Users\Klsunset\Pictures\截图\屏幕截图 2022-01-08 153810.png)

接下来就是复现 LeNet-5 卷积神经网络了

![屏幕截图 2022-01-07 104447](C:\Users\Klsunset\Pictures\截图\屏幕截图 2022-01-07 104447.png)

由架构图可以看到，在第一个卷积层，32*32的图片被卷成了6个28*28的，当然卷积核就是6个5*5的，步长为1。但由于mnist数据集本身就是28*28的图片，所以实现时会有行一些改变。

```
model.add(Conv2D(filters=6, kernel_size=(5,5), strides=(1,1), input_shape=(28, 28, 1), padding='valid', activation='relu'))
```

之后是第一个池化层， LeNet-5使用的是2*2的平均池化。

```
model.add(AveragePooling2D(pool_size=(2,2)))
```

之后是第二个卷积层。它使用16个5*5的卷积核

```
model.add(Conv2D(filters=16, kernel_size=(5,5), strides=(1,1), padding='valid', activation='relu'))
```

之后是第二个相同的池化层。我们需要把最后这个池化层的输出平铺成一个数组。使用Keras的Flatten实现

```
model.add(Flatten())
```

后面的就是全连接层了。由架构图可以看到，最后是个120-84-10的全连接层

```
model.add(Dense(units=120, activation='relu'))
model.add(Dense(units=84, activation='relu'))
model.add(Dense(units=10, activation='softmax'))
```

这样， LeNet-5 网络就搭建好了。之后将mnist数据集送入训练并评估

```
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])
model.fit(X_train, Y_train, epochs=5000, batch_size=2048)

pres = model.predict(X)
plot_utils.show_scatter_surface(X, Y, model)
```

最后得到这样的结果


![屏幕截图 2022-01-07 160439.png](https://www.chinfo.top/static/img/22459a83f9350bf6fd4340e987f44c7f.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-07%20160439.png)

很明显可以看出是比全连接神经网络更好的。

深度学习与卷积神经网络

# 序列依赖问题——文本情感分类

之前的LeNet-5卷积神经网络模型体现了数据在空间上的关联性，但除此之外，数据也有可能在时间上有关联性，比如气温数据，股票数据等。当然，最典型的还是人类的语言。面对这样在时间上有关联的数据，神经网络该如何去识别和处理呢？

我们一般把词作为自然语言处理的基本单位，这样就可以利用“词典”用一个数字来代表一个词，这个数字就是索引值。这样，由词组成的一句话就会转化为一个由数字组成的向量，自然就可以送入神经网络进行识别了。

如果有些词在词典中由于种种原因数据接近，但是含义却相差甚远，这时候如果再进行归一化操作，计算机就很可能错误的识别到完全相反的意思。这样的数据就会给预测模型带来不必要的麻烦。所以我们可以使用one-hot的编码方式对词汇进行编码。通过one-hot编码后每个词都完全不一样。

但是这样进行严格区分的话，又丢失了词汇的关联性。我们可以提取出一个词汇的多个特征值形成一个词向量，即NLP中的词嵌入。

最后我们结合一下one-hot和词向量。让词向量组成的矩阵（字典）点乘按词语组成句子的one-hot编码形成的矩阵，这样就可以提取出句子中每一个词的词向量，这样就可以送入神经网络进行学习了。

明白了原理，我们就来实现一个简单的文本情感分类模型

首先在网上找到了一个别人爬的网购评论的csv文件，然后封装一个shoppingdata.py用来读取和处理这些数据。

```
import os
import keras
import numpy as np
import keras.preprocessing.text as text
import re
import jieba
import random



def load_data():
	xs = []
	ys = []
	with open(os.path.dirname(os.path.abspath(__file__))+'/online_shopping_10_cats.csv','r',encoding='utf-8') as f:
		line=f.readline()#escape first line"label review"
		while line:
			line=f.readline()
			if not line:
				break
			contents = line.split(',')

			# if contents[0]=="书籍":
			# 	continue

			label = int(contents[1])
			review = contents[2]
			if len(review)>20:
				continue

			xs.append(review)
			ys.append(label)

	xs = np.array(xs)
	ys = np.array(ys)

	#打乱数据集
	indies = [i for i in range(len(xs))] 
	random.seed(666)
	random.shuffle(indies)
	xs = xs[indies]
	ys = ys[indies]

	m = len(xs)
	cutpoint = int(m*4/5)
	x_train = xs[:cutpoint]
	y_train = ys[:cutpoint]

	x_test = xs[cutpoint:]
	y_test = ys[cutpoint:]

	

	print('总样本数量:%d' % (len(xs)))
	print('训练集数量:%d' % (len(x_train)))
	print('测试集数量:%d' % (len(x_test)))

	return x_train,y_train,x_test,y_test


def createWordIndex(x_train,x_test):
	x_all = np.concatenate((x_train,x_test),axis=0)
	#建立词索引
	tokenizer = text.Tokenizer()
	#create word index
	word_dic = {}
	voca = []
	for sentence in x_all:
	    # 去掉标点
	    sentence = re.sub("[\s+\.\!\/_,$%^*(+\"\']+|[+——！，。？、~@#￥%……&*（）]+", "", sentence)
	    # 结巴分词
	    cut = jieba.cut(sentence)
	    #cut_list = [ i for i in cut ]

	    for word in cut:
	    	if not (word in word_dic):
	    		word_dic[word]=0
	    	else:
	    		word_dic[word] +=1
	    	voca.append(word)
	word_dic = sorted(word_dic.items(), key = lambda kv:kv[1],reverse=True)

	voca = [v[0] for v in word_dic]
	
	tokenizer.fit_on_texts(voca)
	print("voca:"+str(len(voca)))
	return len(voca),tokenizer.word_index

def word2Index(words,word_index):
	vecs = []
	for sentence in words:
	    # 去掉标点
	    sentence = re.sub("[\s+\.\!\/_,$%^*(+\"\']+|[+——！，。？、~@#￥%……&*（）]+", "", sentence)
	    # 结巴分词
	    cut = jieba.cut(sentence)
	    #cut_list = [ i for i in cut ]
	    index=[]

	    for word in cut:
	    	if word in word_index:
	    		index.append(float(word_index[word]))

	    # if len(index)>25:
	    # 	index = index[0:25]
	    vecs.append(np.array(index))

	return np.array(vecs)
```

首先得到数据的索引表示：

```
x_train_index = shopping_data.word2Index(x_train, word_index)
x_test_index = shopping_data.word2Index(x_test, word_index)
```

因为每句话长短不同，我们需要利用keras.preprocessing中的sequence进行一个对齐操作

```
maxlen = 25
x_train_index = sequence.pad_sequences(x_train_index, maxlen=maxlen)
x_test_index = sequence.pad_sequences(x_test_index, maxlen=maxlen)
```

首先创造一个Sequential模型，堆叠Embedding层，然后利用Flatten把数据平铺开，再送入一个256-256-256的神经网络中进行训练，最后利用sigmoid函数进行输出。

```
model = Sequential()
model.add(Embedding(trainable=Ture, input_dim=vocalen, output_dim=300, input_length=maxlen))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(256, activation='relu'))


model.add(Dense(1, activation='sigmoid'))
```

然后使用交叉熵代价函数和adam优化器，训练200回合，批尺寸为512。

```
model.compile(loss='binary_crossentropy', 
              optimizer='adam',
              metrics=['accuracy'])

model.fit(x_train_index, y_train,
		  batch_size=512,
		  epochs=200)
```

然后开始训练。得到评估结果。


![屏幕截图 2022-01-08 153810.png](https://www.chinfo.top/static/img/38e966b1d62bf2d8e9db054cbda967f5.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-08%20153810.png)

86%的准确度。

序列依赖问题——文本情感分类

# 数组的利用与初识Keras

在之前的学习中我一直使用的是方程的形式进行前向传播梯度下降与反向传播。然而随着输入参数与隐藏层的增多，方程形式似乎不再能胜任如此复杂的工作，这时候就需要引入另一个数学工具——矩阵。

numpy库是一个强大的数学计算库，使用它可以让矩阵的计算变得简单许多。

这是利用方程的代码：

```
w1 = 0.1
w2 = 0.1
b = 0.1

x1s = xs[:,0]#切割第0列形成一个新的数组
x2s = xs[:,1]

def forward(x1s,x2s):
	z = w1*x1s + w2*x2s + b
	a = 1/(1+np.exp(-z))
	return a
plot_utils.show_scatter_surface(xs,ys,forward)

for _ in range(500):
	for i in range(m):
		x = xs[i]
		y = ys[i]
		x1 = x[0]
		x2 = x[1]

		a = forward(x1,x2)

		e = (y-a)**2

		deda = -2*(y-a)
		dadz = a*(1-a)
		dzdw1 = x1
		dzdw2 = x2
		dzdb = 1

		dedw1 = deda*dadz*dzdw1
		dedw2 = deda*dadz*dzdw2
		dedb = deda*dadz*dzdb

		alpha = 0.01
		w1 = w1 - alpha*dedw1
		w2 = w2 - alpha*dedw2
		b = b - alpha*dedb
```

这是利用数组的代码：

```
W = np.array([0.1, 0.1])
B = np.array([0.1])



def forward(X):
	Z = X.dot(W.T) + B
	A = 1/(1+np.exp(-Z))
	return A
plot_utils.show_scatter_surface(X,Y,forward)

for _ in range(500):
	for i in range(m):
		Xi = X[i]
		Yi = Y[i]

		A = forward(Xi)

		E = (Yi-A)**2

		dEdA = -2*(Yi-A)
		dAdZ = A*(1-A)
		dZdW = Xi
		dZdB = 1

		dEdW = dEdA*dAdZ*dZdW
		dEdB = dEdA*dAdZ*dZdB

		alpha = 0.01
		W = W - alpha*dEdW
		B = B - alpha*dEdB
```

可以很直观的发现，使用数组（矩阵）时，代码量会少很多。并且面对越多的输入与隐藏层时，它的优势就会越明显。

当然，它的拟合度也非常的好。


![屏幕截图 2022-01-06 153904.png](https://www.chinfo.top/static/img/088b62716261d5e242cdd2223ebc867a.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-06%20153904.png)

但是，在面对更加复杂的机器学习，比如卷积神经网络，使用这种编写底层代码的方式将会是个大工程。这时候，Keras就自然而然的进入了我的视野，正如它官网上那样：你恰好发现了Keras


![屏幕截图 2022-01-06 153603.png](https://www.chinfo.top/static/img/5734a20de0f09a50c83ff8242208158a.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-06%20153603.png)

现在，是时候走出对神经网络底层知识的学习，开始进入应用层的大门了。

为了展现出Keras相较于手撸底层代码的优势，我使用了新的数据集



![屏幕截图 2022-01-06 154108.png](https://www.chinfo.top/static/img/ab0d49d5dc219c672e23291e4016041e.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-06%20154108.png)

想要拟合这个数据集无疑会很繁琐，相较于上一个，它又增加了新的隐藏层，这样反向传播的求导过程将十分复杂，但使用Keras后，一切都简单了起来。

```
import dataset
import numpy as np
import plot_utils
from keras.models import Sequential 
from keras.layers import Dense 
from tensorflow.keras.optimizers import SGD

m = 100
X, Y = dataset.get_beans4(m)
plot_utils.show_scatter(X,Y)

model = Sequential()
model.add(Dense(units=2, activation='sigmoid', input_dim=2))
model.add(Dense(units=1, activation='sigmoid',))

model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])

model.fit(X, Y, epochs=5000, batch_size=10)

pres = model.predict(X)

plot_utils.show_scatter_surface(X, Y, model)
```

只需要小小的改一个数字就能增加隐藏层，这实在是太方便了。


![屏幕截图 2022-01-06 154732.png](https://www.chinfo.top/static/img/4f5397fd724e67d368226d75ec646425.%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202022-01-06%20154732.png)

效果也是非常的好

数组的利用与初识Keras

# 隐藏层与深度学习

在现实中，判断一个物体，或者说对一个物体下定义，往往不能只从一个方面或两个方面观察。这时候，单个的Rosenblatt感知器已经无法胜任这样复杂的判断，是时候再增加一个神经元了。新增一个神经元，便增加了一个抽象的维度，每个维度通过不断地调整权重并进行激活，从而产生对输入的不同理解，最后再将这些抽象维度中的输出合并并降维得到最后的输出。而这些新添加的神经元，就被称之为隐藏层。

为了直观的看到效果，我还是使用了matplotlib进行绘图。这一次的w和b的值，我选择使用rand()函数生成随机数。并且为了之后的方便，将sigmoid函数（标准Logistic函数）和前向传播封装为两个函数。

```
import dataset
import matplotlib.pyplot as plt
import numpy as np

m = 100
xs, ys = dataset.get_beans(m)



plt.title("STF", fontsize=12)
plt.xlabel("B")
plt.ylabel("T")

plt.scatter(xs, ys)

def sigmoid(x):
	return 1/(1+np.exp(-x))



#第一层
#第一个神经元
w11_1 = np.random.rand()
b1_1 = np.random.rand()
#第二个神经元
w12_1 = np.random.rand()
b2_1 = np.random.rand()

#第二层
w11_2 = np.random.rand()
w21_2 = np.random.rand()
b1_2 = np.random.rand()

#前向传播
def forward(xs):
	#第一层第一个
	z1_1 = w11_1*xs + b1_1
	a1_1 = sigmoid(z1_1)
	#第一层第二个
	z2_1 = w12_1*xs + b2_1
	a2_1 = sigmoid(z2_1)
	#第二层（输出层）
	z1_2 = w11_2*a1_1 + w21_2*a2_1 + b1_2
	a1_2 = sigmoid(z1_2)
	return a1_2,z1_2,a2_1,z2_1,a1_1,z1_1
```

这样准备工作就完成了，接下来就是繁琐的隐藏层求导进行反向传播的过程。

```
for _ in range(5000):
	for i in range(100):
		x = xs[i]
		y = ys[i]
		#先来一次前向传播
		a1_2,z1_2,a2_1,z2_1,a1_1,z1_1 = forward(x)
		#反向传播
		#代价函数e
		e = (y-a1_2)**2

		deda1_2 = -2*(y - a1_2)
		da1_2dz1_2 = a1_2*(1 - a1_2)

		dz1_2dw11_2 = a1_1
		dz1_2dw21_2 = a2_1

		dedw11_2 = deda1_2*da1_2dz1_2*dz1_2dw11_2
		dedw21_2 = deda1_2*da1_2dz1_2*dz1_2dw21_2

		dz1_2db1_2 = 1
		dedb1_2 = deda1_2*da1_2dz1_2*dz1_2db1_2

		#隐藏层的第一个神经元
		dz1_2da1_1 = w11_2
		da1_1dz1_1 = a1_1*(1-a1_1)
		dz1_1dw11_1 = x

		dedw11_1 = deda1_2*da1_2dz1_2*dz1_2da1_1*da1_1dz1_1*dz1_1dw11_1
		dz1_1db1_1 = 1
		dedb1_1 = deda1_2*da1_2dz1_2*dz1_2da1_1*da1_1dz1_1*dz1_1db1_1

		#隐藏层的第二个神经元
		dz1_2da2_1 = w21_2
		da2_1dz2_1 = a2_1*(1-a2_1)
		dz2_1dw12_1 = x

		dedw12_1 = deda1_2*da1_2dz1_2*dz1_2da2_1*da2_1dz2_1*dz2_1dw12_1
		dz2_1db2_1 = 1
		dedb2_1 = deda1_2*da1_2dz1_2*dz1_2da2_1*da2_1dz2_1*dz2_1db2_1

		#梯度下降
		alpha = 0.03
		w11_2 = w11_2 - alpha*dedw11_2
		w21_2 = w21_2 - alpha*dedw21_2
		b1_2 = b1_2 - alpha*dedb1_2

		w12_1 = w12_1 - alpha*dedw12_1
		b2_1 = b2_1 - alpha*dedb2_1

		w11_1 = w11_1 - alpha*dedw11_1
		b1_1 = b1_1 - alpha*dedb1_1
```

经过漫长的求导与修改错误，最后再使用plt.clf()函数和plt.pause()函数相结合绘制动态图像，就得到了最终的结果。




![hidden.gif](https://www.chinfo.top/static/img/52456b9207d242a11906e0cd4fec3e8c.hidden.gif)

当隐藏层变得更多与更深，神经网络也会变得更加强大与智能。当我们设计出一个复杂程度恰当的神经网络，经过不断的训练过后，网络中的各个参数被调节成不同的值，而他们组成的整体，就可以近似出一个相当复杂的函数。

我们一般把隐藏层超过三层的网络称之为深度神经网络。隐藏层的神经元对样本的理解和提取的参数都太过微妙，我们能做的也只有设计一个网络，送入数据进行训练，如果效果好，那它就”起作用了“，效果不好就”没起作用“，只能再次调参，再来一次。这也是为什么深度学习被很多人戏称”炼丹“的原因。