深度学习原理与框架-神经网络-线性回归与神经网络的效果对比 1.np.c_[将数据进行合并] 2.np.linspace(将数据拆成n等分) 3.np.meshgrid(将一维数据表示为二维的维度...

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 

          

转载于:https://www.cnblogs.com/my-love-is-python/p/10490656.html