深度学习-机器学习(神经网络的应用 上)

1.用Python来实现神经网络：

                                        ************具体直接看代码****************

#神经网络算法（Neural Network）
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'):#不指名activation=是默认为'tanh'
        """
        layers：（list）每层里面以后多少个神经元，几个数字就对应几层，每个数字
            的值就对应有多少个神经元，最少要有两层
        self相当于java中的this
        activation-->>激活函数
        """
        if activation == 'logistic':
            self.activation = logistic    #给逻辑函数取名为logistic
            self.activation_deriv = logistic_derivative  #给逻辑函数的导数取名为logistic
        elif activation == 'tanh':
            self.activation = tanh         #给双曲函数取名为tanh
            self.activation_deriv = tanh_deriv      #给双曲函数的导数取名为tanh_deriv

        self.weights = []  #定义一个空的权重list
        #初始化权重的赋值
        for i in range(1, len(layers) - 1):
            """
            随机产生权重 
                       从第二层i开始：对i层的上一层（i-1）和i层的下一层（i+1）,进行赋值
            """
            #i层和i-1层的随机赋值
            self.weights.append((2 * np.random.random((layers[i - 1] + 1, layers[i] + 1)) - 1) * 0.25)
            #i层和i+1层的随机赋值
            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): #learning_rate学习率，epochs=10000：循环的次数
        X = np.atleast_2d(X)#X为训练集，通常为二维的矩阵。
        temp = np.ones([X.shape[0], X.shape[1]+1]) #对偏向的初始化（X.shape[0]为行数，X.shape[1]为列数）
        temp[:, 0:-1] = X  #(:意思是取所有的行)
        X = temp
        y = np.array(y)

        for k in range(epochs):  #epochs=10000循环的次数
            i = np.random.randint(X.shape[0])
            a = [X[i]]   #随机抽取一个数

            for l in range(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])]  # 根据与输出层算出的误差，反向更新

            # Staring backprobagation
            for l in range(len(a) - 2, 0, -1):  # 我们需要从第二层开始到最后一层
                deltas.append(deltas[-1].dot(self.weights[l].T) * self.activation_deriv(a[l]))#更新隐藏层Error
            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)  #权重更新(算法在CSDN上：神经网络算法1)

2 . 下一节  本节训练好的神经网络该怎么用？