Nerual NetWorks - 码农教程

我们都知道神经网络是模拟人的大脑，是深度学习的基础，每一个单元来模拟神经元，每一次计算的输出来模拟突触的放电的过程，但是神经网络并不只是指的一种。

Common nerual NetWorks

FF

Feed forward neural networks 前向神经网络，信息从前向后传播。神经网络通常被描述成多层，其中每一层都由输入、隐藏层、输出单元构成。一层单一网络内部绝对不会有任何连接而通常在相邻的层之间，神经元是完全相连的，最简单某种程度上也是最实用的网络由两个输入单元和一个输出单元，这种网络可以被用作逻辑门模型。通常FFNNs是通过向后传播训练的，给网络成组的数据集包括“输入”和“预想的输出”。这种方式称为有监督学习，误差被向后传播，而误差可以通过MSE或者线性误差来度量。

CNN

Convolutional neural networks 卷积神经网络,他们最初用来做图像处理，后来也用在其他类型的输入数据比如音频。CNN通常以一个输入“扫描仪”开始，而它并不会在解析所有的训练数据。创建一个小的扫描器，然后逐像素向右移动这个扫描器来扫描所有的剩余图像。输入数据然后进行卷积层，同时每个节点都只和她最近的节点相连，这些卷积层也倾向于变小当它们越老越深的时候。特征池化层。池化是一种滤出细节部分的方法：最常用的池化技术是极大值池化。

RNN

Recurrent neural networks 周期神经网络是带时间周期的FFNN：他们不是无状态的；他们在时间上有相关性。神经元不仅从输入接收信息，而且还要接收他们自身前一个周期点的信息。这意味着，我们输入和训练网络的过程是很重要的.RNN一个重要的问题是退化（或爆炸式）梯度问题，依赖于激活函数的使用，信息随着时间快速损失，就像非常深的FFNN随着深度的增加损失信息一样。周期性网络对于演进或补全信息非常有效，比如自动补全。

GAN

Generative adversarialnetworks 生成对抗网络是一种不同的网络，他们是双胞胎：两个网络一起工作。对抗生成网络有任何两个网络组成,通常是FF和CNN的组合），其中一个负责生成内容另一个要判断内容。

我们都知道神经网络中最著名的算法是backpropagation算法

FF神经网络组成

Multilayer Feed-Forward Neural Network

多层向前神经网络由以下部分组成：输入层(input layer), 隐藏层 (hidden layers), 输出层 (output layers)

隐藏层的个数可以是任意的，输入层有一层，输出层有一层，神经网络的层数的计算是不包括输入层，如果有足够多的隐藏层(hidden layers) 和足够大的训练集, 可以模拟出任何方程。神经网络的本质也是通过对很多参数变量的调整来逼近要模拟的函数。

设计神经网络

使用神经网络训练数据之前，必须确定神经网络的层数，以及每层单元的个数
特征向量在被传入输入层时通常被先标准化(normalize）到0和1之间，这样做的原因是为了加速学习过程。
离散型变量可以被编码成每一个输入单元对应一个特征值可能赋的值比如：特征值A可能取三个值（a0, a1, a2), 可以使用3个输入单元来代表A。如果A=a0, 那么代表a0的单元值就取1, 其他取0；如果A=a1, 那么代表a1de单元值就取1，其他取0，以此类推
神经网络即可以用来做分类(classification）问题，也可以解决回归(regression)问题
对于分类问题，如果是2类，可以用一个输出单元表示（0和1分别代表2类）如果多余2类，每一个类别用一个输出单元表示所以输入层的单元数量通常等于类别的数量
没有明确的规则来设计最好有多少个隐藏层根据实验测试和误差，以及准确度来实验并改进

Backpropagation

通过迭代性的来处理训练集中的实例
对比经过神经网络后输入层预测值(predicted value)与真实值(target value)之间误差距离
反方向（从输出层=>隐藏层=>输入层）来以最小化误差(error)来更新每个连接的权重(weight)
算法详细介绍
- 输入：D：数据集，l 学习率(learning rate)，一个多层前向神经网络
- 输出：一个训练好的神经网络(a trained neural network)
- 初始化权重(weights)和偏向(bias): 随机初始化在-1到1之间，或者-0.5到0.5之间，每个单元有一个偏向
- 对于每一个训练实例X，执行以下步骤：

1.正向向前传动

根据误差反向传送输出层反向误差更新：

隐藏层反向误差更新：

终止条件

权重的更新低于某个阈值
预测的错误率低于某个阈值
达到预设一定的循环次数

神经网络的实现

激活函数

tanh()

它的导数为：

1 - tanh()^2

logistic()

他的导数为

logistic()*(1-logistic())

def tanh(x):
    return np.tanh(x)

def tanh_deriv(x):
    return 1.0-np.tanh(x)*np.tanh(x)

def logistic(x):
    return 1/(1+np.exp(-x))

def logistic_deriv(x):
    return logistic(x)*(1-logistic(x))

神经网络算法

class NeuralNetwork:
    #负责选择激活函数，初始化层数，以及所有层的权重
    def __init__(self,layers,activation="tanh")：
    #传入训练数据，学习率，预设循环次数
    def fit(self,x,y,learning_rate=0.2,epochs=10000)

具体的实现

初始化的实现

    def __init__(self,layers,activation="tanh"):
        #选择激活函数
        if activation=="logistic":
            self.activation=logistic
            self.activation_deriv=logistic_deriv
        elif activation=="tanh":
            self.activation=tanh
            self.activation_deriv=tanh_deriv
        #初始化权重数组 
        self.weights=[]
        for i in range(1,len(layers)-1):
            self.weights.append((2*np.random.random((layers[i-1]+1,layers[i]+1))-1)*0.25)
            self.weights.append((2*np.random.random((layers[i]+1,layers[i+1]))-1)*0.25)
            print(str(self.weights))

训练函数实现

  def fit(self,x,y,learning_rate=0.2,epochs=10000):
        x=np.atleast_2d(x)
        temp = np.ones([x.shape[0],x.shape[1]+1])
        temp[:,0:-1]=x
        x=temp
        y=np.array(y)
        
        for k in range(epochs):
            i = np.random.randint(x.shape[0]) #x.shape[0] is the number of the trainingset samples
            a=[x[i]] # choose a sample randomly to train the model
            print(str(a))
            for l in range(len(self.weights)):
                #print("a["+str(l)+"]; "+str(a[l])+"  WEIGHT "+str(self.weights[l])+str(len(self.weights)))
                a.append(self.activation(np.dot(a[l],self.weights[l])))
            error = y[i]-a[-1]
            deltas = [error*self.activation_deriv(a[-1])]
            
            for l in range(len(a)-2,0,-1):
                deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
            deltas.reverse()
            
            for i in range(len(self.weights)):
                layer = np.atleast_2d(a[i])
                delta = np.atleast_2d(deltas[i])
                self.weights[i]+=learning_rate*layer.T.dot(delta)