机器学习-实现简单神经网络（笔记和代码实现）

一、神经网络简介

       神经网络算法的发展历史

       起源：20世纪中叶，一种仿生学产品。

       兴起：环境->2进制创新；能力->软硬件；需求->人的性价比。

       主要功能：

           分类识别

           分类：图像（自动驾驶）、语音（语音助手）、文本（新闻推送）

       （1）了解神经网络的脉络

            训练学习：网络结构、激励函数、损失函数、梯度下降

            网络结构：

    这就是一个神经网络的结构，是一个单层的结构，但是具有输入层、隐含层、输出层、最终预测的值。

    逻辑回归：

        它是一种最简化的网络结构。

    激励函数：

        作用：提供规模化的非线性化能力。

    常用的神经元：

        Sigmoid，它的优点是在整个区间上都是可导，缺点是不对称：

        tanh：

        ReLU：

    目前使用的最多的神经元是ReLU。

    损失函数：

        理解神经网络的相关概念和函数。

    单次训练损失：

    全部训练损失：

    梯度下降：

         理解逻辑回归中的梯度下降。

          对w、b进行同步更新。

    网络向量化：

        理解神经网络的网络向量化。

    以上就是向量化的过程。

    网络梯度下降：

    训练过程：

        通过观察神经网络的学习过程形成较为直观的理解。

    总结：需要理解神经网络的基本结构和核心组件概念。

二、机器学习-实现简单神经网络

    （1）介绍人工智能的基本概念和逻辑体系

    （2）研究两种数据分类算法

    （3）通过python，运用分类算法，实现只有一层的神经网络

    需要构造的神经网络：

    （1）介绍分类算法的理论基础

    （2）使用Pandas，NumPy和matplotlib等python开发库去读取，加工和可视化数据集。

    （3）使用python实现两种分类算法

    分类算法：（1）感知器（2）适应性线性神经元

1. 感知器数据分类算法

    步骤：（权重向量W，训练样本X）

    ▷  把权重向量初始化为0，或把每个分量初始化为[0,1]间任意小数；

    ▷  把训练样本输入感知器，得到分类结果（-1或1）；

    ▷  根据分类结果更新权重向量。

 

    步调函数也叫做激活函数。

    权重和阈值的更新如下：

    感知器算法的适用范围要满足下面第一幅图中的范围：

    感知器算法算法步骤：

2. 自适应线性神经元：

    自适应神经元算法步骤：

    自适应线性神经元与感知器分类算法的区别：

    ▷  第一个：自适应性神经元输入数据计算出结果，然后它会把计算的结果和输入的正确结果进行比较，如果计算的结果与正确结果不一致，它就会根据和已给定结果的差距去动态的调整参数（w0，w1，…，wn）。

    ▷  第二个：自适应性神经元使用的激活函数与感知器用的是不一样的，它不在是步调函数，而是直接把数据和神经参数相乘，所得的结果直接当成最终结果（x0*w0+x1*w1+x2*w2+…+xm*wm）。

    看一看自适应神经元时怎么通过动态调整来调整它的神经元参数，使用的是一种渐进下降的数值算法，不断缩短与正确结果的距离。

    

三、程序代码

      使用python语言进行编写，实现简单的神经网络算法，用感知器算法和自适应神经元两种分类方法对数据集进行分类。

      用到的python版本：python 3.6   

      工具包：numpy、pandas、matplotlib

（1）感知器算法

# -*_coding:utf8-*-
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from matplotlib.colors import ListedColormap


# 感知器算法
class Perceptron(object):
    """
    eta:学习率
    n_iter:权重向量的训练次数
    W：神经分叉权重向量
    errors：用于记录神经元判断出错次数
    """
    # 初始化
    def __init__(self, eta=0.01, n_iter=10):
        self.eta = eta
        self.n_iter = n_iter

    # 神经网络输入
    def net_input(self, X):
        """
        z=W0+W1*X1+...+Xn*Xn
        """
        return np.dot(X, self.w_[1:]) + self.w_[0]
    
    def predict(self, X):
        return np.where(self.net_input(X) >= 0.0, 1, -1)
    # 训练函数
    def fit(self, X, y):
        """
        输入训练数据，培训神经元
        X:输入样本向量
        y:对应样本分类
        X：shape[n_samples，n_features]
        X:[[1,2,3],[4,5,6]]
        y:[1.-1]
        n_samples:2
        n_features:3
        初试话权重向量为0
        """
        self.w_ = np.zeros(1 + X.shape[1])
        self.errors_ = []
        for _ in range(self.n_iter):
            errors = 0
            """
           X:[[1,2,3],[4,5,6]]
           y:[1,-1]
           zip(X,y)=[[1,2,3,1],[4,5,6,-1]] 
           """
            for xi, target in zip(X, y):
                """
                update=η*(y-y')
              """
                update = self.eta * (target - self.predict(xi))
                """
                xi是一个向量
                update * xi 等价：[ΔW(1)=X[1]*update,ΔW(2)=X[2]*update,ΔW(3)=X[3]*update]
              """
                self.w_[1:] += update * xi
                self.w_[0] += update
                errors += int(update != 0.0)
                self.errors_.append(errors)


# 绘图函数
def plot_decision_regins(X, y, classifier, resolutions=0.02):
    marker = ('s', 'x', 'o', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max()
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max()

    print(x1_min, x1_max)
    print(x2_min, x2_max)

    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolutions), np.arange(x2_min, x2_max, resolutions))

    # 预测
    z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    z = z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1], alpha=0.8, c=cmap(idx), marker=marker[idx], label=cl)


file = open("F:/=data.csv")
df = pd.read_csv(file, header=None)
print(df.head(10))

y = df.loc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)

X = df.iloc[0:101, [0, 2]].values

plt.scatter(X[:50, 0], X[:50, 1], color='red', marker='o', label='setosa')
plt.scatter(X[50:100, 0], X[50:100, 1], color='blue', marker='x', label='versicolor')
plt.xlabel("Petal length")
plt.ylabel("Flower diameter length")
plt.legend(loc="upper left")
plt.show()

ppn = Perceptron(eta=0.1, n_iter=10)
ppn.fit(X, y)
plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('sum-squared-error')
plt.show()

plot_decision_regins(X, y, ppn, resolutions=0.02)
plt.xlabel("Petal length")
plt.ylabel("Flower diameter length")
plt.legend(loc="upper left")
plt.show()

（2）自适应神经元

 

 

# -*_coding:utf8-*-
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from matplotlib.colors import ListedColormap


# 自适应神经元
class AdalineGD(object):
    """
    eta:float
    学习率 ：0~1
    n_iter:int
    对训练数据进行学习改进次数
    w_:一维向量
    存储权重数值
    error_：
    存储每次迭代改进时，网络对数据进行错误判断的次数
    """
    # 初始化
    def __init__(self, eta=0.01, n_iter=50):
        self.eta = eta
        self.n_iter = n_iter

    # 神经网络输入
    def net_input(self, X):
        """
        z=W0+W1*X1+...+Xn*Xn
        """
        return np.dot(X, self.w_[1:]) + self.w_[0]

    # 激活函数
    def activation(self, X):
        return self.net_input(X)

    def predict(self, X):
        return np.where(self.net_input(X) >= 0.0, 1, -1)

    # 训练函数
    def fit(self, X, y):
        """
        X:二维数组[n_samples，n_features]
        n_samples:表示X中含有训练数据条目数
        n_features：含有4个数据的一维向量，用于表示一条训练条目
        y:一维向量
        用于存储每一条训练条目对应的正确分类
        """
        self.w_ = np.zeros(1 + X.shape[1])
        self.cost_ = []
        for i in range(self.n_iter):
            output = self.net_input(X)
            errors = (y - output)
            # 神经元参数的更新
            self.w_[1:] += self.eta * X.T.dot(errors)
            self.w_[0] += self.eta * errors.sum()
            cost = (errors ** 2).sum() / 2.0
            self.cost_.append(cost)
        return self


# 绘图函数
def plot_decision_regins(X, y, classifier, resolutions=0.02):
    marker = ('s', 'x', 'o', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max()
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max()

    print(x1_min, x1_max)
    print(x2_min, x2_max)

    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolutions), np.arange(x2_min, x2_max, resolutions))

    # 预测
    z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    z = z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1], alpha=0.8, c=cmap(idx), marker=marker[idx], label=cl)


file = open("F:/data.csv")
df = pd.read_csv(file, header=None)
print(df.head(10))

y = df.loc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)

X = df.iloc[0:101, [0, 2]].values

ada = AdalineGD(eta=0.0001, n_iter=50)
ada.fit(X, y)
plot_decision_regins(X, y, classifier=ada)
plt.title('Adaline-Gradient descent')
plt.xlabel('Petal length')
plt.ylabel('Flower diameter length')
plt.legend(loc='upper left')
plt.show()

plt.plot(range(1, len(ada.cost_) + 1), ada.cost_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('sum-squared-error')
plt.show()

（3）运行结果图

样本数据图

运行错误迭代图

 

感知器算法分类图

运行错误迭代图

自适应神经元分类图

     本文中的数据集下载：data.csv。

     本文代码下载：https://github.com/Messi-Q/The-neural-network/tree/master/venv/Include。