1. np.c[a, b] 将列表或者数据进行合并，我们也可以使用np.concatenate
参数说明：a和b表示输入的列表数据
2.np.linspace(0, 1, N) # 将0和1之间的数分成N份
参数说明：0表示起始数据，1表示末尾数据，N表示生成的分数
3.xx, yy = np.meshgrid(np.arange(x.min(), x.max(), N), np.arange(y.min(), y.max(), N)) 对数据进行切分后，生成二维数据点
参数说明：np.arange(x.min(), x.max(), N) X轴的一维数据，np.arange(y.min(), y.max(), N) y轴一维数据,
4. plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral) 用于生成等高线图
参数说明：xx和yy表示x轴方向的二维数据，yy表示y轴的二维方向的数据，Z表示颜色对应的标签值， cmap表示颜色板
线性网络和神经网络的区别：
第一：线性网络只有一个w*x + b ，即线性变化层， 神经网络可以有多个w*x + b , 且中间存在一个激活层relu
线性回归代码解说：
第一步：使用np.c_[r*sin(t), r*cos(t)] 构造出二维的数据
第二步：前向传播
第一步：前向传播np.dot(x, w) + b 计算得分scores
第二步：使用e^scores / ∑e^scores 计算出概率值
第三步：使用-np.log(probs[np.arange(num_sample, y)]) 计算交叉熵，并且使用np.sum计算总的交叉熵损失值
第三步：反向传播
第一步：计算softamx反向传播的结果，即dout[np.arange(num_sample), y] -= 1 , dout /= num_samples
第二步：计算dx, dw, db， 这里的话也需要加上正则化惩罚项的求导，即w * reg
第四步：更新参数 w = dw*step_size + w, b = db * step_size + b
第五步：使用np.argmax()计算预测值, 利用pred_labels == y.mean() 计算准确率
第六步：使用plt.contourf 画出等高线图
代码：
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0) # 随机种子
N = 100 # 每类样本的个数
K = 3 # 标签值
D = 2 # 维度
X = np.zeros((N*K, D)) # 样本初始化
y = np.zeros(N*K, dtype='int') # 标签初始化
print(y.shape)
# 第一步：使用np.c_构造数据
for j in range(K):
xi = np.arange(j*N, N*(j+1))
r = np.linspace(0.0, 1, N)
t = np.linspace(j*4, (j+1)*4, N) + np.random.randn(N) * 0.2
X[xi] = np.c_[r*np.sin(t), r*np.cos(t)] # 构造样本
y[xi] = j # 构造标签
# 初始化参数
W = np.random.randn(D, K) * 0.01
b = np.zeros((1, K))
reg = 1e-3
step_size = 1e-1
num_examples = X.shape[0]
for i in range(1000):
# 第二步前向传播
# 前向传播计算得分
scores = np.dot(X, W) + b
# 计算概率
softmax_scores = np.exp(scores)
probs = softmax_scores / np.sum(softmax_scores, axis=1, keepdims=True)
# 计算损失值
data_loss = -np.sum(np.log(probs[np.arange(num_examples), y])) / num_examples
reg_loss = 1 / 2 * np.sum(W*W)
loss = data_loss + reg_loss
if i == 100:
print(loss)
# 第三步：计算反向传播
dout = probs
# 求出softmax的反向传播
dout[np.arange(num_examples), y] -= 1
dout /= num_examples
# 求出dW和db
dW = np.dot(X.T, dout)
db = np.sum(dout, axis=0)
# 正则化惩罚项的求导
dW += W * reg
# 第四步：进行参数的更新操作
W = W - step_size * dW
b = b - step_size * db
scores = np.dot(X, W) + b
# 第五步：使用得分，获得最终的准确率
pred_labels = np.argmax(scores, axis=1)
print('accucacy %.2f'%(np.array([pred_labels==y]).mean()))
# 第六步：使用plt.contourf画出等高线图
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()
准确率为0.49
神经网络代码解说：
第一步：使用np.c_[r*sin(t), r*cos(t)] 构造出二维的数据
第二步：前向传播
第一步：前向传播np.dot(x, w1) + b1计算第一层
第二步：np.maximum(np.dot(x1, w2) + b2) 加上一个relu激活函数作为第二层
第三步：使用np.exp(scores) / ∑np.exp(scores) 获得概率值
第四步：使用-np.log(probs[np.arange(num_sample, y)]) 计算交叉熵，并且使用np.sum计算总的交叉熵损失值
第三步：反向传播
第一步：计算softamx反向传播的结果，即dout[np.arange(num_sample), y] -= 1 , dout /= num_samples
第二步：计算dh1, dw2, db2， 这里的话也需要加上正则化惩罚项的求导，即w * reg
第三步：计算relu激活层的反向传播，即dout[x<0] = 0
第四步：计算dw1和db1
第五步：在dw1和dw2的基础上，加上正则化惩罚项的求导，reg * W
第四步：更新参数 w = dw*step_size + w, b = db * step_size + b
第五步：使用np.argmax()计算预测值, 利用pred_labels == y.mean() 计算准确率
第六步：使用plt.contourf 画出等高线图
代码：
import numpy as np
import matplotlib.pyplot as plt
# 随机种子
np.random.seed(0)
N = 100 # 每个样本的个数
K = 3 # 样本的类别
D = 2 # 表示两个维度
X = np.zeros((N*K, D))
y = np.zeros(N*K, dtype='int')
# 第一步：构造数据
for j in range(K):
ix = np.arange(j*N, (j+1)*N)
r = np.linspace(0.0, 1, N)
t = np.linspace((4*j), (j+1)*4, N) + np.random.randn(N) * 0.2
X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j
# 初始化权重参数
W1 = np.random.rand(D, 100) * 0.01
b1 = np.zeros((1, 100))
W2 = np.random.randn(100, K) * 0.01
b2 = np.zeros((1, K))
reg = 1e-3 # 正则化的概率
step_size = 1 # 学习率
num_samples = X.shape[0] # 样本的个数
for i in range(2000):
# 第二步：循环，进行前向传播
# 第一层得分值的获得
h1 = np.dot(X, W1) + b1
# 使用relu激活层
relu_h1 = np.maximum(0, h1)
# 进行第二层的前向传播
scores = np.dot(relu_h1, W2) + b2
# 计算概率值
probs = np.exp(scores)
probs = probs / np.sum(probs, axis=1, keepdims=True)
# 计算损失值
data_loss = -np.sum(np.log(probs[np.arange(num_samples), y])) / num_samples
# 正则化惩罚项的损失值
reg_loss = 1 / 2 * np.sum(W1*W1)*reg + 1/2 * np.sum(W2*W2)*reg
loss = data_loss + reg_loss
# 进行反向传播
# softmax的反向传播结果
dout = probs.copy()
dout[np.arange(num_samples), y] -= 1
dout /= num_samples
# 第二层反向传播的结果
dh1 = np.dot(dout, W2.T)
dw2 = np.dot(relu_h1.T, dout)
db2 = np.sum(dout, axis=0)
# relu层反向传播的结果
drelu = dh1.copy()
drelu[h1 < 0] = 0
# 第一层方向传播的结果
dw1 = np.dot(X.T, drelu)
db1 = np.sum(drelu, axis=0)
# 在获得梯度权重的基础上加上正则化的梯度值
dw2 += reg * W2
dw1 += reg * W1
# 第四步：进行参数的更新
W2 -= dw2 * step_size
b2 -= db2 * step_size
W1 -= dw1 * step_size
b1 -= db1 * step_size
if i%100 == 0:
print(loss)
# 第五步：根据得分值，计算准确率
predict_labels = np.argmax(scores, axis=1)
print('accuracy:%.2f'%np.array([predict_labels==y]).mean())
# 第六步：进行画图操作
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
# 计算出对应的类别值
Z = np.dot(np.maximum(np.dot(np.c_[xx.ravel(), yy.ravel()], W1) + b1, 0), W2) + b2
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()
准确率0.95
