摘要

本文是作者看慕课网学习记录笔记,内容技术水准是入门,大佬看到请轻言指点,手下留情
  1. 介绍人工智能的基本概念和逻辑体系
  2. 研究两种麵分类算法
  3. 通过python ,运用分类算法,实现只有一层的神经网络

介绍分类算法的理论基础

机器学习的本质:模拟人的神经元

神经元

图片描述

人工神经元原理:

  1. 电信号从神经元的交差部分(左侧)输入
  2. 进入到细胞核(左侧绿色)进行结合到一起,进行统一计算得出一个电信号
  3. 通过轴突(中间黄色部分)传递到后面的神经末尾部分(右侧)
  4. 再把电信号分解成若干个部分,传递给外面的神经元

神经元的数学模拟

图片描述

图片描述

  1. x表示传进来的电信号,每个x表示每个电信号;对电信号进行弱化,弱化系数w;
  2. 弱化后的电信号传入细胞核,综合处理后得出唯一的电信号z;细胞核还会对电信号继续处理(激活函数,示例单元步调函数),即数据分类行为。

常见的数学运算概念

  1. 向量点积
    图片描述
  2. 矩阵转置
    图片描述

感知器数据分类算法步骤

步骤

权重向量W,训练样本Ⅹ

  1. 把权重向量初始化为0,或把每个分量初始化为[0,1]间任意小数
  2. 把训练样本输入感知器,得到分类结果(-1或1)
  3. 根据分类结果更新权重向量

步调函数与阀值

图片描述

权重更新算法

图片描述

图片描述

图片描述

图片描述

阀值的更新

图片描述

感知器算法试用范围

预测数据特点可线性分割,要求可以把感知的值有一条线明确分割出来,目标就是找到中间的分割线

图片描述

感知器算法总结

图片描述

  1. 初始化感知器权重向量w
  2. 训练样本的电信号x输入到感知器∑(求和),输出求和的最终结果
  3. 求和结果输入到步调函数(激活函数),得到结果1或-1
  4. 如果结果正确就直接输出,错误就返回回去对权重向量w进行更新,更新之后等到新的权重向量w后
  5. 再把原有的训练样本或者新的训练样本结合新的权重向量w进行结合,继续步骤2后续操作
  6. 通过上述步骤直到所有训练样本都正确输出,达到最准确的权重向量w

使用 Pandas, NumPy和 matplotlib等 python开发库去读取,加工和可视化数据集,并实现感知器分类算法

源码地址:klinson/machine-learning-python

Python 环境

Python3.7.3

安装

自行下载Python环境包

需要安装tkinter

// centos
sudo yum install tkinter
// ubuntu
sudo apt-get install tkinter

// cd python-path
sudo ./configure --with-tcltk-includes="-I/usr/include" --with-tcltk-libs="-L/usr/lib64 -ltcl8.5 -L/usr/lib64 -ltk8.5" --enable-optimizations
sudo make && sudo make install

感知器类实现

文件名Perceptron.py

# -*- coding: utf-8 -*-
import numpy as np

class Perceptron(object):
    """
    Perceptron
    感知器算法
    eta: 学习率
    n_iter: 权重向量的训练次数
    w_: 神经分叉权重向量
    errors_: 用来记录神经元判断出错次数
    """
    def __init__(self, eta = 0.01, n_iter = 0):
        self.eta = eta;
        self.n_iter = n_iter;
        pass

    def fit(self, X, y):
        """
        权重更新算法
        根据输入样本,进行神经元培训,x是输入样本向量,y对应样本分类

        X:shape[n_samples, n_features]
        X:[[1, 2, 3], [4, 5, 6]]
        n_samples: 2
        n_features: 3
        """

        # 初始化权重为0
        # 加一是因为前面算法提到的w0,是步调函数阈值
        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]]
            target = 1 / -1
            """
            for xi, target in zip(X, y):
                """
                update = n(成功率) * (y - y'),结果为0表示预测正确
                target: y,预定结果
                self.predict(xi): y', 对xi进行预测结果
                """
                update = self.eta * (target - self.predict(xi));
                

                """
                xi 是一个向量
                update * xi 等级:
                [▽w(1) = x[1] * update, ▽w(2) = x[2] * update, ▽w(n) = x[n] * update]
                """
                self.w_[1:] += update * xi;

                # 更新阈值
                self.w_[0] += update;

                errors += int(update != 0.0)
                self.errors_.append(errors);
                pass
            pass
        pass

    def net_input(self, X):
        """
        实现向量点积
        z = W0*x0+W1*x1+...+Wn*xn;
        """

        return np.dot(X, self.w_[1:] + self.w_[0])
        pass

    def predict(self, X):
        # 计算xn所属于的分类,先进行点积,再进行判断
        return np.where(self.net_input(X) >= 0.0, 1, -1);
        pass    

执行文件

文件名main.py

# -*- coding: utf-8 -*-
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
import numpy as np
from Perceptron import Perceptron


def plot_decision_regions(X, y, classifier, resolution=0.02):
    #画图划线分割

    markers = ['s', 'x', 'o', 'v'];
    colors= ['red', 'blue', 'lightred', '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, x2_min, x2_max);

    # 根据数据最大最小值构建向量,差值resolution
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))
    #print(np.arange(x1_min, x1_max, resolution).shape, np.arange(x1_min, x1_max, resolution), xx1.shape, xx1)

    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=markers[idx], label=cl)
        pass

    plt.xlabel('花瓣长度');
    plt.ylabel('花径长度');
    plt.legend(loc='upper left');
    plt.show();
    pass


# 读取文件
file = './examples.csv';
df = pd.read_csv(file, header=None);
# print(df.head(10))

# 处理第4列表
y = df.loc[0: 100, 4].values;
y = np.where(y == 'Tris-setosa', -1, 1);
# print(y)

# 讲第0和2列取出来分析
X = df.iloc[0: 100, [0, 2]].values;
# print(X)

# 对数据可视化
"""
plt.scatter(X[:5, 0], X[:5, 1], color='red', marker='o', label='setosa'),;
plt.scatter(X[5:10, 0], X[5:10, 1], color='blue', marker='x', label='versicolor');
plt.xlabel('花瓣长度');
plt.ylabel('花径长度');
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('错误分类次数');
plt.show();
"""

# 绘制分割图
plot_decision_regions(X, y, ppn, resolution=0.02)

训练数据

文件名examples.csv

2.1,3.5,2.7,0.2,Tris-setosa
3.1,2.6,2.6,0.2,Tris-setosa
2.1,5.5,3.4,0.5,Tris-setosa
3.1,5.2,2.9,0.2,Tris-setosa
3.1,3.4,2.3,0.3,Tris-setosa
3.1,2.3,2.1,0.2,Tris-setosa
4.7,3.5,1.4,0.2,Tris-versicolor
4.3,7.3,1.1,0.1,Tris-versicolor
4.1,4.5,1.4,0.2,Tris-versicolor
4.4,4.2,1.3,0.3,Tris-versicolor

执行和结果

$ python main.py 

图片描述

适应性线性神经元

未完待续,敬请期待

klinson
141 声望12 粉丝