深度学习: 神奇的DeepLearning

真如我们在第六节课中说的那样, 深度学习, 就是不断的增加一个神经网络的隐藏神经元, 让输入的数据被这些神经元不断的抽象和理解, 最后得到一个具有泛化能力的预测网络模型。

而我们一般把隐藏层超过三层的网络, 称之为"深度神经网络", 如此说来"深度学习"这个听起来相当高端大气上档次尤其是近些年被媒体包装的十分具有神秘感的名字. 瞬间也就觉得没那么道貌岸然了, 只有每个神经元在理解什么, 很难用精确的数学手段去分析, 我们唯一能做的就是, 搜集数据, 送入数据, 进行训练, 然后期待结果, 当然也不是说我们对一个深度神经网络完全不可把控. 起码我们能在比如, 学习率, 激活函数, 神经元层数和数量等等方面, 调节神经网络的大致工作行为, 俗称---调参。

我们以著名的tensorflow游乐场为例, 很多初学者在一开始接触神经网络的时候, 大概率都会被一个神秘的力量引导到这个网站来, 这样点两下就可以搭建神经网络的体验真不错, 但除了真不错以外, 这些参数怎么设置, 神经元怎么搭建合适, 就很懵懂了, 而经过前几课的学习, 我们在对神经网络的工作原理有了相对系统的了解之后, 这些东西都将变得明朗起来。

那这节课我们就来把玩这个经典的入门神奇. get到一点调参的感觉。

# dataset.py
import numpy as np
import random

def get_beans(counts):
    posX,posY = genSpiral(int(counts/2),0,1)
    negX,negY = genSpiral(int(counts/2),np.pi,0)
    X = np.vstack((posX,negX))
    Y = np.hstack((posY,negY))
    return X,Y

def genSpiral(counts,deltaT, label):
    X = np.zeros((counts,2))
    Y = np.zeros(counts)
    for i in range(counts):
        r = i / counts * 5
        t = 1.75 * i / counts * 2 * np.pi + deltaT;
        x1 = r * np.sin(t) + random.uniform(-0.1,0.1)
        x2 = r * np.cos(t) + random.uniform(-0.1,0.1)
        X[i] = np.array([x1,x2])
        Y[i] = label
    return X,Y 

def dist(a, b):
    dx = a['x'] - b['x'];
    dy = a['y']- b['y'];
    return np.sqrt(dx * dx + dy * dy);
def getCircleLabel(p, center):
    radius = 1;
    if dist(p, center) 

# plot_utils.py
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
from keras.models import Sequential#导入keras

def show_scatter_curve(X,Y,pres):
    plt.scatter(X, Y) 
    plt.plot(X, pres) 
    plt.show()

def show_scatter(X,Y):
    if X.ndim>1:
        show_3d_scatter(X,Y)
    else:
        plt.scatter(X, Y) 
        plt.show()

def show_3d_scatter(X,Y):
    x = X[:,0]
    z = X[:,1]
    fig = plt.figure()
    ax = Axes3D(fig)
    ax.scatter(x, z, Y)
    plt.show()

def show_surface(x,z,forward_propgation):
    x = np.arange(np.min(x),np.max(x),0.1)
    z = np.arange(np.min(z),np.max(z),0.1)
    x,z = np.meshgrid(x,z)
    y = forward_propgation(X)
    fig = plt.figure()
    ax = Axes3D(fig)
    ax.plot_surface(x, z, y, cmap='rainbow')
    plt.show()

def show_scatter_surface(X,Y,forward_propgation):
    if type(forward_propgation) == Sequential:
        show_scatter_surface_with_model(X,Y,forward_propgation)
        return
    x = X[:,0]
    z = X[:,1]
    y = Y

    fig = plt.figure()
    ax = Axes3D(fig)
    ax.scatter(x, z, y)

    x = np.arange(np.min(x),np.max(x),0.1)
    z = np.arange(np.min(z),np.max(z),0.1)
    x,z = np.meshgrid(x,z)

    X = np.column_stack((x[0],z[0]))
    for j in range(z.shape[0]):
        if j == 0:
            continue
        X = np.vstack((X,np.column_stack((x[0],z[j]))))

    print(X.shape)
    r = forward_propgation(X)
    y = r[0]
    if type(r) == np.ndarray:
        y = r

    y = np.array([y])
    y = y.reshape(x.shape[0],z.shape[1])
    ax.plot_surface(x, z, y, cmap='rainbow')
    plt.show()

def show_scatter_surface_with_model(X,Y,model):
    #model.predict(X)

    x = X[:,0]
    z = X[:,1]
    y = Y

    fig = plt.figure()
    ax = Axes3D(fig)
    ax.scatter(x, z, y)

    x = np.arange(np.min(x),np.max(x),0.1)
    z = np.arange(np.min(z),np.max(z),0.1)
    x,z = np.meshgrid(x,z)

    X = np.column_stack((x[0],z[0]))

    for j in range(z.shape[0]):
        if j == 0:
            continue
        X = np.vstack((X,np.column_stack((x[0],z[j]))))

    print(X.shape)
    y = model.predict(X)

    # return
    # y = model.predcit(X)
    y = np.array([y])
    y = y.reshape(x.shape[0],z.shape[1])
    ax.plot_surface(x, z, y, cmap='rainbow')
    plt.show()

def pre(X,Y,model):
    model.predict(X)

# beans_predict.py
import dataset
import numpy as np
import plot_utils
from tensorflow.keras.models import Sequential
from tensorflow.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()
# units 当前层神经元数量
# activation 激活函数类型
# input_dim 输入数据特征维度
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'))

# loss 代价函数 mean_squared_error (均方误差)
# optimizer 优化器 sgd(随机梯度下降算法)
# metrics 评估标准 accuracy(准确度)
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])

# epochs 训练回合数
# batch_size 训练批数量
model.fit(X, Y, epochs=5000, batch_size=10)

pres = model.predict(X)
# 曲线图
# plot_utils.show_scatter_curve(X,Y,pres)
# 曲面图
plot_utils.show_scatter_surface(X, Y, model)

print(model.get_weights())