【吴恩达机器学习笔记】Part2-Week1 神经网络（Neural Network）_吴恩达机器学习 pytorch week1

1.1 引言

神经网络（Neural Network）
深度学习算法（Deep Learning Algorithms）
决策树（Decision Trees）

Week1：Neural Network-inference（prediction）
Week2：Neural Network-training
Week3：Practical advice for building machine learning systems
Week4：Decision Trees

本周内容：神经网络+如何进行推理/预测

How to carry out inference or prediction.

1.2 神经元和大脑

神经网络算法的早期动机是试图构建模仿大脑运作的算法，后来改名为深度学习算法，随着互联网和大数据的兴起一度火了起来。
GPU-Graphic Processing Units

1.3 需求预测（Demand Prediction）

三个layer分别叫做：输入层（input layer）、隐藏层（hidden layer）、输出层（output layer）；每一个layer对输入的向量维度（即特征个数）进行了缩减，直至输出层输出一个结果。
总的来说，深度学习算法通过对输入的特征和数据进行自行提取，不需要我们通过直觉或经验提取特征，在hidden layer算法会自己计算出需要使用的特征。这使深度学习算法具有强大的学习能力，和不易解释的特点。
主要问题——神经网络架构问题（neural network architecture）：如何决定学习过程有多少个hidden layers，以及每个hidden layer有多少个神经元neurons。
有些文献管神经网络/深度学习叫多层感知器（multilayer perception），其实这几个叫法指同一个东西。

1.4 应用-面部识别（Face Recognition）

案例描述：训练一个神经网络模型，以一百万个像素灰度值作为特征向量为输入，以图片中人的身份为输出。过程中，算法会先从较小的像素窗格开始学习，找出特征；再下一个hidden layer中会进一步放大像素窗格，针对五官进行识别；接下来会对整体面部特征识别；最终得出结果。

2.1 神经网络中的网络层（Neural Network Layer）

假设一个神经网络模型有3个网络层：layer 0, layer 1, layer 2；
layer 0是输入层；
layer 1对上一层传入的数据进行逻辑回归处理，设有该层三个神经元，每个神经元是一个逻辑回归模型，在其w和b参数加上标[n]表示第n个网络层，加下标m表示第m个神经元；每个神经元输出一个activation值，此例中layer 1输出3个a值，即一个三维a向量；
layer 2只有一个神经元，同样对从layer 1输入的向量（3个数据）进行逻辑回归，最终输出一个标量作为结果。

2.2 更复杂的神经网络（more complex neural network）

每网络层的公式表示：
$$a_j^{[l]}=g\left({\vec{w}}_j^{[l]}\cdot {\vec{a}}^{[l-1]}+b_j^{[l]}\right)$$

2.3 神经网络前向传播（Forward Propagation）

案例：手写数字识别（handwritten digit recognition）
所谓前向传播，就是从输入第一个图层到最后一个图层逐步递进的过程。

3.1 用代码实现推理（inference）

常用工具：TensorFlow和pytorch。这里用的是TensorFlow。
用units替换神经元（neurons），用dense替换神经层（layers）。

x = np.array([[200.0, 17.0]])
layer_1 = Dense(units=3, activation='sigmoid')
a1 = layer_1(x)

layer_2 = Dense(units=1, activation='sigmoid')
a2 = layer_2(a1)

if a2 >= 0.5:
	yhat = 1
else:
	yhat = 0
1
2
3
4
5
6
7
8
9
10
11

3.2 TensorFlow中的数据形式

numpy中一维向量（1D vector）和二维矩阵（2D matrix）的区分：

x = np.array([[200, 17]])			#1*2矩阵[200 17]
y = np.array([[200],
			  [17]])				#2*1矩阵
z = np.array([200, 17])				#一维向量（200， 17）
1
2
3
4

在TensorFlow中使用矩阵而非向量。
【TensorFlow与numpy的转化】

3.3 搭建一个神经网络

layer_1 = Dense(units=3, activation="sigmoid")
layer_2 = Dense(units=1, activation="sigmoid")
model = Sequential([layer_1, layer_2])				#使用sequential形成神经网络，将layer串联在一起
model.compile(...)
x = np.array([[0,..., 245,...,17],
			  [0,...,200,...,184]])
y = np.array([1, 0])
model.fit(x, y)
model.predict(x_new)								#前向传播（Forward Propagation），推理（inference）/预测（prediction）
1
2
3
4
5
6
7
8
9

4.1 单个网络层上的前向传播（Forward prop in a single layer）

x = np.array([200,17])								#1D array
w1_1 = np.array([1,2])								#layer1中有3个神经元（units），设定第一个神经元的逻辑回归参数
b1_1 = np.array([-1])
z1_1 = np.dot(w1_1,x)+b
a1_1 = sigmoid(z1_1)								#建立逻辑回归模型并计算第一个units的activation，a1_1
# 以同样的方法计算a1_2，a1_3
a1 = np.array([a1_1, a1_2, a1_3])
1
2
3
4
5
6
7

4.2 前向传播的一般实现（Forward prop in Numpy）

W = np.array([[1,-3,5]								#将3个units的二维w向量组合为矩阵形式
 			  [2,4,-6]])
b = np.array([-1,1,2])								#将3个units的标量b组合为一维数组
a_in = np.array([-2,4])								#a_0/a_in/x，输入值

def dense(a_in,W,b,g):
	units = W.shape[1]								#units=3
	a_out = np.zeroes(units)						#a_out=[0,0,0]
	for j in range(units):
		w = W[:,j]
		z = np.dot(w,a_in) + b[j]
		a_out[j] = g(z)
	return a_out									#输出[1,0,1]

def sequential(x):
	a1 = dense(x,W1,b1)
	a2 = dense(a1,W2,b2)
	a3 = dense(a2,W2,b2)
	a4 = dense(a3,W3,b3)
	f_x = a4
	return f_X
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.1 强人工智能（Speculations on Artificial General Intelligence-AGI）

AI与AGI。

6.1 神经网络为什么这么高效（How neural networks are implemented efficiently）

前向传播的神经网络实现：

#使用了np.matmul和矩阵乘法
W = np.array([[1,-3,5]								#将3个units的二维w向量组合为矩阵形式
 			  [2,4,-6]])
b = np.array([-1,1,2])								#将3个units的标量b组合为一维数组
A_in = np.array([[-2,4]])							#A_in/x，输入值，注意这里使用了矩阵

def dense(A_in,W,B):								#这里输入的A_in是矩阵
	Z = np.matmul(A_in,W) + B						#调用np.matmul进行矩阵乘法，提高了运算效率
	A_out = g(Z)
	return A_out									#输出[[1,0,1]]矩阵
1
2
3
4
5
6
7
8
9
10

6.2 矩阵乘法

6.3 矩阵乘法规则

6.4 矩阵乘法代码

A = np.array([1,-1,0.1],
			 [2,-2,0.2])
AT = np.array([1,2],								#A的转置
			  [-1,-2],
			  [0.1,0.2])
AT = A.T											#A的转置的另一种表示

W = np.array([3,5,7,9],
			 [4,6,8,0])

Z = np.matmul(AT,W)									#AT和W的矩阵相乘并赋值给Z，np.matmul
Z = AT @ W											#矩阵相乘的另一种表示
1
2
3
4
5
6
7
8
9
10
11
12