python 深度学习DeepLearning（学习笔记）

• python 深度学习DeepLearning（学习笔记）
  • 什么是深度学习DeepLearning？
  • Tensorflow游乐场
    • 豆豆普通分类实践
    • 豆豆圆形分类实践
    • 异或数据集
    • 螺旋数据集
  • 编码实践

什么是深度学习DeepLearning？

深度学习就是不断增加一个神经网络的隐藏层神经元，让输入的数据被这些神经元不断的抽象和理解，最后得到一个具有泛化能力的预测网络模型，一般我们把隐藏层超过三层的网络模型称为深度神经网络。
这个过程有时会很难用数学的方式进行理解它在理解什么，当然我们可以通过收集数据、送入数据、进行训练然后期待结果。
我们也可以通过设置学习率、激活函数、神经元数量，来调节神经网络的大致行为，俗称调参。

我们以tensorflow为例，http://playground.tensorflow.org/ 。

Tensorflow游乐场

我们可以看到这里有四种数据集，我们可以先尝试一下第三种数据集。

豆豆普通分类实践

红色的豆豆表示无毒，蓝色的豆豆表示有毒，我们可以设置我们熟悉的Sigmoid进行训练，并设置学习率为0.03，然后点击开始训练。

我们发现它做出了很好的分类。

豆豆圆形分类实践

我们再来看第一种，上面圆圈蓝色是有毒的豆豆，下面黄色是无毒的豆豆。

通过分析我们发现三条线可以很好的进行闭合形成一个圆圈，所以我们在Tensorflow游乐场中可以添加三个神经元进行训练。

异或数据集

当时为了证明感知器模型没有什么用处，便提出了异或的问题。

异或问题：相同的数为1，不同的数为0，这样如此简单的数都无法进行区别，导致神经网络在当时处于很长的一个低谷期。

这里我们同样通过3个神经元可以进行训练，从而得出的我们想要达到的目的，但这是为什么？待会会进行解释。

螺旋数据集

这种像蚊香一样的螺旋数据集，我们使用三个隐藏层每层四个神经元进行训练发现非常的吃力。

这是由于我们的sigmoid函数出现了问题，导数远离了中心位置但是导数可导依旧不为0，但是导数很小，这样梯度下降就很难进行。

所以现在的人们很难使用sigmoid进行训练模型，而是使用Relu的激活函数。
在线性结果z大于0的使用输出值为z，而在z小于0的时候固定为0，这样在z大于0的时候处处可导而且不会出现梯度消失的情况。
在z=0的时候从数学上来看这个折点确实不可导，但如果真的遇到这个点需要特殊处理一下了。
Relu的缺陷：当然如果a小于0的部分，很有可能让神经元死亡，也就是所谓的Dead Relu Problem,因为在反向传播的时候链式求导法则中，如果激活函数是0梯度为权重将无法更新。

所以人们又改进了relu为reaky-relu，在z小于0的时候输出不再是0而是一个缓缓倾斜的直线，这样就可以避免死亡relu问题

当然关于梯度消失的问题有很多，直接使用relu函数进行训练模型同样可以达到很好训练效果。
如果没有特别的需求Relu一定是首选。
我们再此使用Tensorflow游乐场选择Relu函数并在每一层加到八个神经元进行训练，会发现可以得到很好效果。

编码实践

接下来我们通过编码来对螺旋形数据集进行实践。

首先准备数据。

import numpy as np
import random
def get_beans9(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) < (radius * 0.5):
        return 1
    else:
        return 0
def randUniform(a=-1, b=1):
  return np.random.rand() * (b - a) + a;
def classifyCircleData(numSamples=100, noise=0):
    points = [];
    Y = []
    X = []
    radius = 1;
    num = int(numSamples/2)
    for i in range(num):
        r = randUniform(0, radius * 0.5);
        angle = randUniform(0, 2 * np.pi);
        x = r * np.sin(angle);
        y = r * np.cos(angle);
        noiseX = randUniform(-radius, radius) * noise;
        noiseY = randUniform(-radius, radius) * noise;
        label = getCircleLabel({'x': x + noiseX, 'y': y + noiseY}, {'x': 0, 'y': 0});
        X.append([x+1,y+1])
        Y.append(label)
    for i in range(num):
        r = randUniform(radius * 0.7, radius);
        angle = randUniform(0, 2 * np.pi);
        x = r * np.sin(angle);
        y = r * np.cos(angle);
        noiseX = randUniform(-radius, radius) * noise;
        noiseY = randUniform(-radius, radius) * noise;
        label = getCircleLabel({'x': x + noiseX, 'y': y + noiseY}, {'x': 0, 'y': 0});
        X.append([x+1,y+1])
        Y.append(label)
    X = np.array(X)
    Y = np.array(Y)
    return X,Y

设置为与Tensorflow游乐场一样，三层隐藏层每层8个神经元。

import dataset
import numpy as np
import plot_utils_2
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
m = 100
X,Y = dataset.get_beans9(m)
# 显示散点图
plot_utils_2.show_scatter(X,Y)
# 设置训练层以及神经元数量
model = Sequential()
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'))
# 设置策略，0.05的阿尔法每次，按照准确率
model.compile(loss='mean_squared_error',optimizer=SGD(lr=0.05),metrics=['accuracy'])
model.fit(X, Y, epochs=5000, batch_size=10)
pres = model.predict(X)
plot_utils_2.show_scatter_surface(X,Y,model)
print(model.get_weights())