# 第十二篇：《机器学习之神经网络（实战篇）》

```import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

# 放置数据的点
np.random.seed(0)
N = 100 # 每类点数
D = 2 # 维度
K = 3 # 类别数目
X = np.zeros((N*K,D))
y = np.zeros(N*K, dtype='uint8')
for j in range(K):
ix = range(N*j,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 # theta
X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
y[ix] = j

fig = plt.figure(figsize=(11,11))
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.show()```
```h = 200 # 隐藏层大小
W = 0.01 * np.random.randn(D,h)# x:300*2  2*100
b = np.zeros((1,h))
W2 = 0.01 * np.random.randn(h,K)
b2 = np.zeros((1,K))

# 一些超参数
step_size = 1e-0
reg = 1e-3 # 正则化强度

# 梯度下降环
num_examples = X.shape[0]

# 进行迭代训练模型
for i in range(10000):
# 评价班级成绩, [N x K]
hidden_layer = np.maximum(0, np.dot(X, W) + b) # note, ReLU activation hidden_layer:300*100
#print hidden_layer.shape
scores = np.dot(hidden_layer, W2) + b2  #scores:300*3
#print scores.shape

# 计算类概率
exp_scores = np.exp(scores)

probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]

#print probs.shape

# 计算损耗：平均交叉熵损失与正则化

corect_logprobs = -np.log(probs[range(num_examples),y])

data_loss = np.sum(corect_logprobs)/num_examples

reg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2)

loss = data_loss + reg_loss

if i % 1000 == 0:
print ("训练第 %d 次: 误差 %f" % (i, loss))

# 计算分数的梯度
dscores = probs
dscores[range(num_examples),y] -= 1
dscores /= num_examples

# 反向传播 参数的梯度
# 首先 反向传播 into parameters W2 and b2
dW2 = np.dot(hidden_layer.T, dscores)
db2 = np.sum(dscores, axis=0, keepdims=True)
# 然后 反向传播 into hidden layer
dhidden = np.dot(dscores, W2.T)
# 反向传播 the ReLU non-linearity
dhidden[hidden_layer <= 0] = 0
# 最后 into W,b
dW = np.dot(X.T, dhidden)
db = np.sum(dhidden, axis=0, keepdims=True)

# 添加正则化梯度贡献
dW2 += reg * W2
dW += reg * W

# 执行参数更新
W += -step_size * dW
b += -step_size * db
W2 += -step_size * dW2
b2 += -step_size * db2

hidden_layer = np.maximum(0, np.dot(X, W) + b)
scores = np.dot(hidden_layer, W2) + b2
predicted_class = np.argmax(scores, axis=1)
print ('训练后的准确度: %.2f' % (np.mean(predicted_class == y)))

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(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b), W2) + b2
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)

fig = plt.figure(figsize=(9,9))
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)

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()```

198 篇文章30 人订阅

0 条评论

## 相关文章

### 1×1卷积的用途（Network in Network）

1×1卷积，又称为Network in Network ? 如果卷积的输出输入都只是一个平面，那么1x1卷积核并没有什么意义，它是完全不考虑像素与周边其他像...

1.2K7

### 机器学习算法KNN简介及实现

KNN(K近邻算法)是一种不需要学习任何参数同时也非常简单的机器学习算法，既可以用来解决分类问题也可以用来解决回归问题。直观解释这个算法就是'近朱者赤，近墨者黑...

1200

1947

991

1084

992

3483

4735

48811

3737