模型的搭建按照自己的想法设计的，源码共7个.py文件，如下图：
　　

　　按照创建先后顺序，分别是：data.py，layer.py，network.py，activation.py，loss.py，train.py，evaluate.py。data.py用于获取数据并对数据进行预处理，layer.py创建了一个Layer类，用来表示第L层，network.py抽象了一个网络类，将传入的若干层通过计算输入输出连接起来，组成一个网络，data.py用来读取数据，loss.py明确了交叉熵损失函数和其导数，activation.py分别写了激活函数relu和sigmoid以及其导函数，train.py创建了层次并组成网络，然后对数据进行训练并保存模型，最后evaluate.py用于对测试集进行测试。
　　网络分为2大块，正向传播和反向传播：
　　但是不管是正向还是反向，网络中的每一层都可以抽象出来，因此创建一个layer类：
　　正向传播的L层：
　　反向传播的L层：
　　在写代码之前，最重要的是确定每个变量和参数的维度：
　　正向传播：
　　注意：n[L]表示当前层(即第L层)中的神经元个数，n[L-1]表示前一层(即L-1层)的神经元个数，例如在本次程序中，n[0]=12288，n[1]=1000，n[2]=500，n[3]=1
　　反向传播：
　　1. data.py
　　# coding: utf-8
　　# 2019/7/20 18:59
　　import h5py
　　import numpy as np
　　def get_train():
　　f = h5py.File('dataset/train_catvnoncat.h5','r')
　　x_train = np.array(f['train_set_x'])#训练集数据 将数据转化为np.array
　　y_train = np.array(f['train_set_y'])#训练集标签
　　return x_train,y_train
　　def get_test():
　　f = h5py.File('dataset/test_catvnoncat.h5', 'r')
　　x_test = np.array(f['test_set_x'])#测试集数据 将数据转化为np.array
　　y_test = np.array(f['test_set_y'])#测试集标签
　　return x_test,y_test
　　def preprocess(X):
　　#将X标准化，从0-255变成0-1
　　# X =X / 255
　　#将数据从(m,64,64,3)变成(m,12288)
　　X = X.reshape([X.shape[0], X.shape[1]*X.shape[2]*X.shape[3]]).T
　　return X
　　if __name__ == '__main__':
　　x1,y1 = get_train()
　　x2,y2 = get_test()
　　print(x1.shape,y1.shape)
　　print(x2.shape,y2.shape)
　　from matplotlib import pyplot as plt
　　plt.figure()
　　for i in range(1,16):
　　plt.subplot(3,5,i)
　　plt.imshow(x1[i])
　　print(y1[i])
　　plt.show()
　　2. layer.py
　　# coding: utf-8
　　# 2019/7/21 9:22
　　import numpy as np
　　class Layer:
　　def __init__(self,nL,nL_1,activ,activ_deri, learning_rate):
　　#参数分别表示：当前层神经元个数，前一层神经元个数，激活函数，激活函数的导函数，学习率
　　self.nL = nL
　　self.nL_1 = nL_1
　　self.g = activ
　　self.g_d = activ_deri
　　self.alpha = learning_rate
　　self.W = np.random.randn(nL,nL_1)*0.01
　　self.b = np.random.randn(nL,1)*0.01
　　#正向传播：
　　#1、计算Z=WX+b
　　#2、计算A=g(Z)
　　def forward(self,AL_1):
　　self.AL_1 = AL_1
　　assert (AL_1.shape[0] == self.nL_1)
　　self.Z = np.dot(self.W,AL_1)+self.b
　　assert (self.Z.shape[0] == self.nL)
　　AL = self.g(self.Z)
　　return AL
　　#反向传播：
　　#1、m表示样本个数
　　#2、计算dZ，dW，db，dAL_1
　　#3、梯度下降，更新W和b
　　def backward(self,dAL):
　　assert (dAL.shape[0] == self.nL)
　　m = dAL.shape[1]
　　dZ = np.multiply(dAL,self.g_d(self.Z))
　　assert (dZ.shape[0] == self.nL)
　　dW = np.dot(dZ,self.AL_1.T)/m
　　assert (dW.shape == (self.nL,self.nL_1))
　　db = np.mean(dZ,axis=1,keepdims=True)
　　assert (db.shape == (self.nL,1))
　　dAL_1 = np.dot(self.W.T,dZ)
　　assert (dAL_1.shape[0] == self.nL_1)
　　#梯度下降
　　self.W -= self.alpha*dW
　　self.b -= self.alpha*db
　　return dAL_1
　　3. network.py
　　# coding: utf-8
　　# 2019/7/21 10:45
　　import numpy as np
　　class Network:
　　def __init__(self,layers,loss,loss_der):
　　self.layers = layers
　　self.loss = loss
　　self.loss_der = loss_der
　　#根据输入的数据来调用正向传播函数，不断更新A，最后得到预测结果
　　def predict(self,X):
　　A = X
　　for layer in self.layers:
　　A = layer.forward(A)
　　return A
　　#连接每个层组建网络：
　　#1、根据输入的数据进行正向传播，得到预测结果Y_predict
　　#2、根据Y_predict和真实值Y，通过损失函数来计算成本值J
　　#3、根据J来计算反向传播的输入值dA
　　#4、调用反向传播函数来更新dA
　　def train(self,X,Y,epochs=10):
　　for i in range(epochs):
　　Y_predict = self.predict(X)
　　J = np.mean(self.loss(Y, Y_predict))
　　print('epoch %d:loss=%f'%(i,J))
　　dA = self.loss_der(Y,Y_predict)
　　for layer in reversed(self.layers):
　　#更新dA
　　dA= layer.backward(dA)
　　4. loss.py
　　# coding: utf-8
　　# 2019/7/21 11:34
　　import numpy as np
　　#交叉熵损失函数
　　def cross_entropy(y, y_predict):
　　y_predict = np.clip(y_predict,1e-10,1-1e-10) #防止0*log(0)出现。导致计算结果变为NaN
　　return -(y * np.log(y_predict) + (1 - y) * np.log(1 - y_predict))
　　#交叉熵损失函数的导函数
　　def cross_entropy_der(y,y_predict):
　　return -y/y_predict+(1-y)/(1-y_predict)
　　5. activation.py
　　# coding: utf-8
　　# 2019/7/21 9:49
　　import numpy as np
　　def sigmoid(z):
　　return 1 / (1 + np.exp(-z))
　　#sigmoid导函数
　　def sigmoid_der(z):
　　x = np.exp(-z)
　　return x/((1+x)**2)
　　def relu(z):无锡妇科医院 http://www.xasgyy.net/
　　return np.maximum(0,z)
　　#relu导函数
　　def relu_der(z):
　　return (z>=0).astype(np.float64)
　　6. train.py
　　# coding: utf-8
　　# 2019/7/21 12:13
　　import data,layer,loss,network,activation
　　import pickle,time
　　#对数据集进行训练并保存模型
　　#1、搭建3层网络层
　　#2、将3个层组建成网络
　　#3、获取训练集数据
　　#4、对输入值X进行预处理
　　#5、将数据输入网络进行训练，epochs为1000
　　#6、将整个模型保存
　　if __name__ == '__main__':
　　learning_rate = 0.01
　　L1 = layer.Layer(1000,64*64*3, activation.relu, activation.relu_der, 
learning_rate)
　　L2 = layer.Layer(500,1000,activation.relu, activation.relu_der, 
learning_rate)
　　L3 = layer.Layer(1,500, activation.sigmoid, activation.sigmoid_der, 
learning_rate)
　　net = network.Network([L1,L2,L3], loss.cross_entropy, 
loss.cross_entropy_der)
　　X,Y = data.get_train()
　　X = data.preprocess(X)
　　net.train(X,Y,1000)
　　with 
open('models/model_%s.pickle'%(time.asctime().replace(':','_').replace(' 
','-')),'wb') as f:
　　pickle.dump(net,f)
　　7. evaluate.py
　　# coding: utf-8
　　# 2019/7/21 14:17
　　import data
　　import pickle
　　import numpy as np
　　if __name__ == '__main__':
　　model_name = 'model_Sun-Jul-21-14_41_42-2019.pickle'
　　#导入模型
　　with open('models/'+model_name,'rb') as f:
　　net = pickle.load(f)
　　#获取测试数据集
　　X,Y = data.get_test()
　　X = data.preprocess(X)
　　#根据输入数据X进行预测
　　Y_predict = net.predict(X)
　　Y_pred_float = (Y_predict>0.5).astype(np.float64)
　　#计算精确度
　　accuracy = np.sum(np.equal(Y_pred_float,Y).astype(np.int))/Y.shape[0]
　　print('accuracy:',accuracy)
　　结果
　　


				

推荐学习网站：http://playground.tensorflow.org/，这个网站就是用Tensorflow.js写出来的；
多层神经网络：XOR逻辑回归
同为0，异为1



操作步骤：

加载XOR数据集
定义模型结构：多层神经网络

初始化一个神经网络模型
为神经网络模型添加两个层
设计层的神经元个数，inputShape,激活函数


训练模型并预测





演示代码：

<!-- index.html  -->
<form action="" onsubmit="predict(this);return false;">
    x: <input type="text" name="x">
    y: <input type="text" name="y">
    <button type="submit">预测</button>
</form>

// index.js
import * as tf from '@tensorflow/tfjs';
import * as tfvis from '@tensorflow/tfjs-vis';
import { getData } from './data.js';

window.onload = async() => {
    const data = getData(400); // 获取400个点

    tfvis.render.scatterplot(
        {name:'XOR 训练数据'},
        {
            values: [
                data.filter(p => p.label === 1),
                data.filter(p => p.label === 0)
            ]
        }
    );

    const model = tf.sequential();
    // 设置隐藏层
    model.add(tf.layers.dense({
        units: 4, // 神经元个数为4
        inputShape: [2], // 长度为2的一维数组，数据特征为2：x,y
        activation: 'relu' // 激活函数 非线性
    }));
    // 设置输出层
    model.add(tf.layers.dense({
        units:1, // 只需要输出一个概率
        activation: 'sigmoid' // 输出0-1之间的概率
    }));
    
    // 设置损失函数和优化器
    model.compile({
        loss:tf.losses.logLoss,
        optimizer: tf.train.adam(0.1)
    });

    const inputs = tf.tensor(data.map(p => [p.x,p.y]));
    const labels = tf.tensor(data.map(p => p.label));

    await model.fit(inputs,labels,{
        epochs:10,
        callbacks:tfvis.show.fitCallbacks(
            {name:'训练过程'},
            ['loss']
        )
    });

    window.predict = async (form) => {
        const pred = await model.predict(tf.tensor([[form.x.value*1,form.y.value*1]]))
        alert(`预测结果：${pred.dataSync()[0]}`);
    }

}

// data.js
export function getData(numSamples) {
    let points = [];
  
    function genGauss(cx, cy, label) {
      for (let i = 0; i < numSamples / 2; i++) {
        let x = normalRandom(cx);
        let y = normalRandom(cy);
        points.push({ x, y, label });
      }
    }
  
    genGauss(2, 2, 0);
    genGauss(-2, -2, 0);
    genGauss(-2, 2, 1);
    genGauss(2, -2, 1);
    return points;
  }
  
  /**
   * Samples from a normal distribution. Uses the seedrandom library as the
   * random generator.
   *
   * @param mean The mean. Default is 0.
   * @param variance The variance. Default is 1.
   */
  function normalRandom(mean = 0, variance = 1) {
    let v1, v2, s;
    do {
      v1 = 2 * Math.random() - 1;
      v2 = 2 * Math.random() - 1;
      s = v1 * v1 + v2 * v2;
    } while (s > 1);
  
    let result = Math.sqrt(-2 * Math.log(s) / s) * v1;
    return mean + Math.sqrt(variance) * result;
  }

作者：Bipolar Bear

链接：https://www.zhihu.com/question/26017374/answer/127924427

来源：知乎

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。


以我的理解，两种网络被设计出来，所要解决的问题和目的不同。
多层神经网络与universal approximation theorem [1] （泛逼近性原理，不知这样翻译可对？）相伴而生。该理论指出，单隐藏层（hidden layer）非线性前馈神经网络，可以在实数空间近似任何连续函数。上世纪80 90年代，Backpropagation 刚刚开始大行其道，利用这一算法，只需知道输入和输出便可训练网络参数，从而得到一个神经网络“黑箱”。之所以称为黑箱，是因为无需知道y=f(x) 中f的表达式是什么，也能轻易做函数计算，因为f（objective function）就是网络本身。多层神经网络的座右铭是：“函数是什么我不管，反正我能算！“。

当然多层神经网络并非天下无敌，它有三个主要限制：
一是在面对大数据时，需要人为提取原始数据的特征作为输入，这个问题前面的知友提到过@杨延生。必须忽略不相关的变量，同时保留有用的信息。这个尺度很难掌握，多层神经网络会把蹲在屋顶的Kitty和骑在猫奴头上的Kitty识别为不同的猫咪，又会把二哈和狼归类为同一种动物。前者是对不相关变量过于敏感，后者则因无法提取有实际意义的特征。
二是想要更精确的近似复杂的函数，必须增加隐藏层的层数，这就产生了梯度扩散问题@青青子衿。所谓“强弩之末势不能穿鲁缟“。
三是无法处理时间序列数据（比如音频），因为多层神经网络不含时间参数。

随着人工智能需求的提升，我们想要做复杂的图像识别，做自然语言处理，做语义分析翻译，等等。多层神经网络显然力不从心。那么深度模型是如何解决以上三个问题的。

第一，深度学习自动选择原始数据的特征。举一个图像的例子，将像素值矩阵输入深度网络（这里指常用于图像识别的卷积神经网络CNN），网络第一层表征物体的位置、边缘、亮度等初级视觉信息。第二层将边缘整合表征物体的轮廓……之后的层会表征更加抽象的信息，如猫或狗这样的抽象概念。所有特征完全在网络中自动呈现，并非出自人工设计。更重要的一点是这种随着层的深入，从具象到抽象的层级式表征跟大脑的工作原理吻合，视网膜接收图像从LGN到视皮层、颞叶皮层再到海马走的是同样的路数[2]！
第二，深度网络的学习算法。一种方法是改变网络的组织结构，比如用卷积神经网络代替全连接（full connectivity）网络，训练算法仍依据Backpropagating gradients的基本原理。另一种则是彻底改变训练算法，我尝试过的算法有Hessian-free optimization[3]，recursive least-squares(RLS) 等。
第三，使用带反馈和时间参数的Recurrent neural network 处理时间序列数据。从某种意义上讲，Recurrent neural network可以在时间维度上展开成深度网络，可以有效处理音频信息（语音识别和自然语言处理等），或者用来模拟动力系统。





深度学习是一种学习方式，指的是采用深度模型进行学习，不是模型。多层神经网络是一种模型。
问题转成深度模型和多层神经网络的区别。多层神经网络只要够深就能称为深度模型。但是深度模型不止只有够深的多层神经网络一种，还有 DBM、DBN 等图模型，也有一些带反馈的神经网络如 RNN 什么的。

4.多层神经网络优化的一些技巧

在多层神经网络的实战中，很多参数看上去都是由设计人员直观的判断而得到的，例如网络的层数以及各个结点的数量。而诸如权值的初始化，下降梯度的选择，看似不论选择什么样的数值，总会迎来收敛（其区别仅在于收敛速度的快慢）。其实不然，多层神经网络由于其网络的复杂性，其问题往往会变成一个非凸的高维优化问题，这样，在构建高层神经网络的时候就必须注意到收敛速度以及最优解是否会出现的问题。 

以下是笔者收集到的一些关于多层神经网络优化时的技巧。



4.1.随机梯度下降

在公式推导中，所得到的梯度为所有样本的一阶导数综合推得的值（batch gradient）,在处理大量高维样本时，这样的梯度计算方法往往会因为要遍历所以样本数据得到梯度而表现出极慢的速度。所以在实例中一般使用随机梯度下降（stochastic gradient）。即仅对训练样本集中的一个样本求其梯度，并将此梯度作为全局梯度进行训练。尽管在单个梯度来看，随机选择一个梯度不能很好的代替全局梯度，但是其在统计意义上却能够很好的和整体收敛趋势相吻合。虽然随机梯度下降使得梯度在每一次没有完全和全局梯度一致而减缓了收敛速度，但是其凭借着出色的计算性能可以获得比计算全局梯度更快的速度。而且，使用随机梯度样本可以在一定程度上抑制过拟合问题。对于样本集合的变动也具有更高的适应性。 

但是，全局梯度下降也有自身的优势：其可以获得理论意义上的全局最优，也有更多的优化手段可以选择（比如梯度共轭算法就需要使用全局梯度，以及一些二阶导数相关的操作），其在公式推导的意义上也更易于理解）。 

所以部分学者综合前两者的优势，提出了最小集合梯度下降（min-batch gradient），在每一次优化使用一个样本集合的子集进行梯度计算，并且在后期逐渐增大集合的大小，以达成较好的收敛性能。



4.1.1随机梯度下降算法的收敛速度

随机梯度下降算法的收敛速度可能是很多学习者存疑的地方，虽然从直观上来理解，随机选择向量所得梯度其“趋势”与全局梯度可以达到近似，实际上这种近似所引入的不确定性和计算全局梯度所付出的代价实际上是一个均衡问题。下面我们援引[2]的文档对随机梯度下降的收敛做一个简单的说明：

随机梯度下降的收敛速度被数据集的噪声所制约着。其将影响随机梯度下降方法的性能，尤其是在错误样本较多的情况下，随机梯度下降算法可能会付出比全局梯度下降算法高很多的代价。
随机梯度下降算法的性能随着步长的缩减也在下降。因其本来已经是一种全局梯度下降的近似，在步长过小的情况下其性能也可能降低到很低。
4.2.样本标准化与随机选择原则

在随机梯度下降算法中，朴素的思路是完全随机的在样本集合中选择训练样本完成优化。但是从实践而言，网络通常在处理“最特殊”的样本的时候对其训练有着最大的帮助。这样，其实就引出了另外一个问题：如何选取最异常（abnormal）的样本。下面，我们将通过样本规范化的方法来导出一个最异常样本的选取原则。 

为了便于计算，首先需要将样本的期望变为0，假设输入样本集合{Z}∈Rn

,Zij表示其第i个样本的第j维,样本数目为m个。这样，对于每个样本： 
Z^i=Zi−1m∑k=0mZk


使其期望变为0。这样，数据集的方差计算就变为了： 
δ2=∑k=0mZ^k2


可以发现，这时候每个数据对于整体方差的贡献直接与其平方项有关了，这样，只要通过比较每个数据的模，就可以推断出其在数据集合的异常程度。由此，我们获得了选取异常量的一个标准。 

但是，样本的各个维度之间可能仍然存在着严重的线性依赖关系，这对于我们训练得到一个良好的模型是不利的。为了消除样本各个维度之间的依赖关系，还需要对其进行更多的处理。KL变换并进行协方差均衡是一种有效的数据处理手段，KL变换将数据的协方差矩阵化为对角阵，此时的数据集合将会沿着几个主轴向量分布，各个维数据的依赖性会降低到最小。此时再使用协方差均衡化，可以使得特征选择的在各个维度都存在相同的标准。其处理流程如图所示。



另一方面，样本的标准化是有助于优化系数的。设想一个高维向量，其多个维度都与某一个维度表现出强烈的线性依赖性。这样的数据进行训练的话，实际上会出现较多的没有什么作用的结点，从而增加网络的复杂程度并拖延训练速度。

5.优化系数初始化



5.1.sigmiod函数族

sigmiod函数族即形似S的一组函数，其在机器学习领域有着举足轻重的作用。通常目标的线性分割函数找到之后，需要一个映射函数将其赋予不同的标签。阶跃函数虽然有着很好的标签区分性能，但是其阶跃出难以求导，使其难以在梯度下降框架中进行优化。于是，人们使用sigmiod函数族来替代阶跃函数。常用的sigmiod函数用logist函数f(x)=11+e−x以及tanh函数f(x)=ex−e−xex+e−x。



5.2.初始值选取

因为激活函数使用了sigmiod函数，故而系数的初始值范围不能够过大，太大的值会使得输出过大，由于sigmiod函数在数值很大的时候函数曲线都趋于平稳，所以此时会得到一个很小的梯度，不利于收敛。所以，系数的初始化需要满足：

系数足够大以保证良好的决策性能
系数不会过大以确保梯度
在文献[3]中，指出对于tanh函数而言，其初始化系数应该在[−6fanin+fanout−−−−−−−−−√均匀选择,6fanin+fanout−−−−−−−−−√]其中fanin,fanout为该层的输入、输出结点数目。而对于logist函数来说，其系数区域应该为[−46fanin+fanout−−−−−−−−−√,46fanin+fanout−−−−−−−−−√].



5.3.步长选取

对于不同的输入输出结点，理应选择不同的优化步长进行处理。在迭代次数加深的同时缩短步长也是一种有效减少在目标值附近震荡的方法。但是其初始步长的选取依然是令人疑惑的一个问题。首先为了让每次的步长都能够让函数最优下降，我们需要在每次迭代解答loss(a)=f(xk+αgrad)的最小化问题，诚然，这是非常费时费力的一种做法。 

现在，让我们重新审视梯度迭代公式： 
xt=xt−1−η∂f∂x


目标函数的泰勒展开为： 
f(x)=f(x0)+(x−xo)df(x0)dx+(x−xo)2d2f(x0)2dx2+...


取前两项，并且两边对于x求导，有： 
df(x)dx=df(x0)dx+(x−xo)d2f(x0)dx2


假设x=xmin使得df(xmin)dx=0,此时有： 
0=df(x0)dx+(xmin−xo)d2f(x0)dx2


可得： 
xmin=x0−d2f(x0)dx2−1df(x0)dx


可以发现，当步长为hession矩阵的逆的时候，函数可以达到最有效的下降。而在实际运用中，一般仅计算一次hession来估计应该选取的步长，再逐步降低步长的选择。



6.待解决问题

MLP的缺陷

网络的隐含节点个数选取问题至今仍是一个世界难题 

在训练过程中，如果网络节点数目不足，会造成表示能力不够从而无法很好的分割出目标，但是当结点数目过多的时候同样会影响训练速度。造成训练难以收敛。所以选择合适数目的结点至关重要，但是现在并没有成熟的理论来指导选择结点的数目，一般来说只有按照计算机的计算性能通过多多益善的思路增加数目来达到良好的训练效果
停止阈值、学习率、动量常数需要采用”trial-and-error”法，极其耗时。 

尽管在前文我们已经学习了一些系数的优化极其选择方法，仍然有部分系数难以确定其合适的具体数值。同网络结点的数目确定一样，现在一般也还是只有使用试错的方法去不断调整。
学习速度慢 

学习速度的问题既和硬件条件有关，也和算法的设计有关。在感知机算法刚被发现的几年，人们曾经狂热于感知机算法的优越性，但是很快被多层网络所需要的极大计算量所打败。多年之后，计算机的性能和大数据时代成就了深度学习，但是如今的计算资源依然是有限的。所以我们无法全部仰仗计算机强劲的性能，仍需强大的算法或者新的架构来提升能力。
容易陷入局部极值，学习不够充分 

由于其表达能力的强大，也似的多层神经网络容易陷入过拟合状态，陷入局部极值并难以摆脱。现代方法中诸如”drop realy”一定程度上改善了这样的情况，但是过拟合的仍然无法完全避免。强劲有力的算法仍等待人们发现。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
参考资料

[1] Hornik K, Stinchcombe M, White H. Multilayer feedforward networks are universal approximators[J]. Neural networks, 1989, 2(5): 359-366. 

[2] Bottou L. Stochastic gradient descent tricks[M]//Neural Networks: Tricks of the Trade. Springer Berlin Heidelberg, 2012: 421-436. 

[3] Glorot X, Bengio Y. Understanding the difficulty of training deep feedforward neural networks[C]//International conference on artificial intelligence and statistics. 2010: 249-256.