深度学习-机器学习（神经网络的应用下）

********************************先看代码后面解释********************************

#神经网络算法（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)
    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

#神经网络算法下
import numpy as np
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)
for i in [[0,0],[0,1],[1,0],[1,1]]:
    print(i,nn.predict(i))

运行的结果为：

1.看运行的结果可以得到：

y = np.array([0,1,1,0])

第一个值为：0，运行结果的第一行就近似为0

第一个值为：1，运行结果的第二行就近似为1

第一个值为：1，运行结果的第三行就近似为1

第一个值为：0，运行结果的第四行就近似为0

就可以看出预测的成功，如果你把代码里面的

y = np.array([0,1,1,0])

改为：[1,0,0,1] 结果就会和料想的一样：会有四个近似的值1,0,0,1

深度学习-机器学习（神经网络的应用 下）

猜你喜欢

深度学习-机器学习（神经网络的应用下）