1，神经网络的概念：我们用一张图来了解一下吧！
多层向前神经网络由以下部分组成：
输入层(input layer), 隐藏层 (hidden layers), 输入层 (output layers)
补充：一般第一层是输入层，最后一层是输出层，其他的的都是中间层，而且我们数层次的时候不算第一层。
2，设计神经网络结构
2.1 使用神经网络训练数据之前，必须确定神经网络的层数，以及每层单元的个数
2.2 特征向量在被传入输入层时通常被先标准化(normalize）到0和1之间 （为了加速学习过程）
2.3 离散型变量可以被编码成每一个输入单元对应一个特征值可能赋的值
比如：特征值A可能取三个值（a0, a1, a2), 可以使用3个输入单元来代表A。
如果A=a0, 那么代表a0的单元值就取1, 其他取0；
如果A=a1, 那么代表a1de单元值就取1，其他取0，以此类推
2.4 神经网络即可以用来做分类(classification）问题，也可以解决回归(regression)问题
2.4.1 对于分类问题，如果是2类，可以用一个输出单元表示（0和1分别代表2类）
如果多余2类，每一个类别用一个输出单元表示
所以输入层的单元数量通常等于类别的数量
2.4.2 没有明确的规则来设计最好有多少个隐藏层
2.4.2.1 根据实验测试和误差，以及准确度来实验并改进
3，Backpropagation算法
3.1 通过迭代性的来处理训练集中的实例
3.2 对比经过神经网络后输入层预测值(predicted value)与真实值(target value)之间
3.3 反方向（从输出层=>隐藏层=>输入层）来以最小化误差(error)来更新每个连接的权重(weight)
3.4 算法详细介绍
输入：D：数据集，l 学习率(learning rate)， 一个多层前向神经网络
输入：一个训练好的神经网络(a trained neural network)
3.4.1 初始化权重(weights)和偏向(bias): 随机初始化在-1到1之间，或者-0.5到0.5之间，每个单元有
一个偏向
3.4.2 对于每一个训练实例X，执行以下步骤：
3.4.2.1： 由输入层向前传送到中间层：
中间层计算公式如下：
中间层到输出层框图如下：
公式和上面的一致。
每次计算出来的输出值必须归一化，最简单的的输出归一化公式如下：
注：下面所使用到的归一化公式Oj就是使用的这个公式。
误差分析：我们向前传播结束后我们需要反向走一遍来更新一下每个输入到输出的权值，使得误差值达到最小。
补充循环终止条件如下几种情况：
1 权重的更新低于某个阈值
2 预测的错误率低于某个阈值
3 达到预设一定的循环次数
误差计算：
输出层：
#Tj是真实值
隐藏层：
权重更新: 
偏向更新： 
向后反馈神经网络举例说明：
补充：4节点的输出值计算：x4 = x1*w14+x2*w24+x3*w34+Q4的偏移值 =1*0.2+0*0.4+1*(-0.5)+（-0.4）= -0.7
归一化后为0.332；
5节点的输出值计算： x5 = x1*w15+x2*w25+x3*w35 +Q5的偏移值 = 1*(-.03)+0*0.1+1*0.2+0.2 = 0.1
归一化后为0.525；
6节点的输出值计算： x6 = x4*w46+x5*w56+Q6的偏移值 = 0.332*(-0.3)+0.525*(-0.2)+0.1 = -0.105
归一化后为0.474；
然后使用归一化公式来转化输出值,此输出值这就是后面要用的0i。
误差计算以及反馈来更新输出值以及权重，
举例计算：6节点的误差计算：Eiij = 0j(1-0j)(Tj-0j) = 0.474*（1-0.474）*（1-0.474) =0.131
权重更新：
Wij = (l)Errj*0i ； Wij = Wij +Wij 即46节点之间的权值更新,l表示取到的权值：
W4,6 = -0.3 +0.9*0.131*0.332 = -0.261
偏移值更新：6点的偏移值更新如下：0j = (l)Eiij = 0.9*0.131
0j =0j+0j = 0.1+0.9*0.131 = 0.218
其他的各点计算总结如下：
python代码实现：在spader里面新建一个NeuralNetwork.py
import numpy as np
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_derivative(x):
return logistic(x)*(1-logistic(x))
class NeuralNetwork:
#构造函数
def __init__(self, layers, activation='tanh'):
"""
:param layers: A list containing the number of units in each layer.
Should be at least two values
:param activation: The activation function to be used. Can be
"logistic" or "tanh"
"""
if activation == 'logistic':
self.activation = logistic
self.activation_deriv = logistic_derivative
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)
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 # adding the bias unit to the input layer
X = temp
y = np.array(y)
for k in range(epochs):
i = np.random.randint(X.shape[0])
a = [X[i]]
for l in range(len(self.weights)): #going forward network, for each layer
a.append(self.activation(np.dot(a[l], self.weights[l]))) #Computer the node value for each layer (O_i) using activation function
#a[-1]表示最后一层的值
error = y[i] - a[-1] #Computer the error at the top layer
deltas = [error * self.activation_deriv(a[-1])] #For output layer, Err calculation (delta is updated error)
#Staring backprobagation
for l in range(len(a) - 2, 0, -1): # we need to begin at the second to last layer
#Compute the updated error (i,e, deltas) for each node going from top layer to input layer
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)
def predict(self, x):
x = np.array(x)
temp = np.ones(x.shape[0]+1)
temp[0:-1] = x
a = temp
for l in range(0, len(self.weights)):
a = self.activation(np.dot(a, self.weights[l]))
return a
调用自己写的神经网络来实现一个简单的预测：
我们来通过神经网络来计算异或的值:例如输入:[[0,0],[0,1],[1,0],[1,1]],输出值为[0,1,1,0],接下来我们来新建一个test1.py来预测一下我们输入之后通过神经网络算法之后的输出。
from NeuralNetwork import NeuralNetwork
import numpy as np
#[2,2,1]是输入层，中间层，输出层
nn = NeuralNetwork([2, 2, 1], 'tanh')
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])
nn.fit(X, y) #神经网络中的训练函数，就是上面的NeuralNetwork.py里面的fit函数
for i in [[0, 0], [0, 1], [1, 0], [1, 1]]:
print(i, nn.predict(i))运行结果如下：
数字识别处理：
# from sklearn.datasets import load_digits
#
# digits= load_digits()
# print(digits.data.shape)
#
# import pylab as pl
# pl.gray()
# pl.matshow(digits.images[0])
# pl.show()
#!/usr/bin/python
# -*- coding:utf-8 -*-
# 每个图片8x8 识别数字：0,1,2,3,4,5,6,7,8,9
#from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import LabelBinarizer
from NeuralNetwork import NeuralNetwork
#from sklearn.cross_validation import train_test_split
from sklearn.model_selection import train_test_split
#下载数据
from sklearn.datasets import load_digits
import numpy as np
from sklearn.metrics import classification_report,confusion_matrix
#下载数据
digits = load_digits()
#取数据
x= digits.data
y = digits.target
#将x转为0和1
x -= x.min()
x /= x.max()
#64输入层，100隐藏层，10输出层
nn = NeuralNetwork([64,100,10],"logistic")
#x_train为训练集，x_test为测试集
x_train,x_test,y_train,y_test = train_test_split(x,y)
#将数据都转化为0和1
label_train = LabelBinarizer().fit_transform(y_train)
label_test = LabelBinarizer().fit_transform(y_test)
print("start fitting..")
predictions = []
#x_train是训练的数据，调用神经网络函数训练
nn.fit(x_train, label_train, epochs=10000)
for i in range(x_test.shape[0]):
o = nn.predict(x_test[i]) #预测x标签对应的y
predictions.append(np.argmin(o)) #最大概率
#打印预测值
print(confusion_matrix(y_test,predictions))
#计算精确度
print(classification_report(y_test,predictions))结果分析：
第一个打印矩阵中对角线表示预测正确的个数，比如说预测0正确的个数是31个
第二个矩阵中的参数解释：
precision:在预测的数据中有多少是正确的：比如说0的预测正确率是0.97（97%），表明预测为0的照片中97%的是0
recall:在照片中真实值为0的值在预测中真的为0，比如0的预测正确率为1（100%）。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
