Rosenblatt感知器

Rosenblatt感知器是一种最简单的感知器模型，即输出值为输入与对应权值相乘后取和再累加并加上偏置后通过符号函数的结果，即：Output = sgn(w0 * x0 + w1 * x1 + ... + wn * xn + bias)。
训练时，使用有监督学习，当输出值与真实值不同时，对应的weight与该次输入数据与真实值和学习率的乘积相加，或可以描述为weight += input * (d - o) * n其中，input为输入值，d为真实值，o为输出值，n为学习率

Python实现

Rosenblatt神经元的实现

通过Rosenblatt感知器的数学模型，可以很简单的使用numpy库实现感知机功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import numpy as np


class Rosenblatt(object):
    """docstring for Rosenblatt"""

    def __init__(self, InputNum):
        super(Rosenblatt, self).__init__()
        self.Weight = np.zeros([InputNum + 1, 1])
        self.TrainRaito = 1
    
    //激活函数（符号函数）
    def ActivitionFunction(self, InputData):
        #  print(InputData, np.zeros(InputData.shape))
        #  print((InputData > np.zeros(InputData.shape)).all())
        if (InputData > np.zeros(InputData.shape)).all() == True:
            #  print("1")
            return 1
        else:
            #  print("-1")
            return -1

  • (InputData > np.zeros(InputData.shape)).all()表示当InputData中的每一个元素都大于0时，返回True，与此相似的还有.any()，只要有一个元素满足即返回True
  • 需要注意的是这里的==不可改为is，否则会出现奇怪的情况
    1
    2
    3
    4
    //前馈传播
    def Feedforward(self, InputData):
        return self.ActivitionFunction(
            np.matmul(self.Weight.T, np.hstack((np.ones([1, 1]), InputData)).T))
  • 这里的.T表示矩阵的转置，注意二维矩阵转置才是符合要求的，一维矩阵的转置行为有点奇怪。
  • np.hstack((a,b))函数表示在第0维上垛堞a和b矩阵
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //训练
    def TrainOneStep(self, InputData, RightResult):
        Result = self.Feedforward(InputData)
        if Result != RightResult:
            self.ChangeWeight(InputData, RightResult, Result)

    //修改权值
    def ChangeWeight(self, InputData, RightResult, Result):
        #  print(self.TrainRaito *
        #        (RightResult - Result))
        self.Weight += self.TrainRaito * \
            (RightResult - Result) * np.hstack((np.ones([1, 1]), InputData)).T

    //设置学习率
    def SetTrainRatio(self, Ratio):
        self.TrainRaito = Ratio

    双月数据集

    本次测试使用的是双月数据集，如下图所示：

该数据集是一个线性不可分的数据集，上方的半月的真实值为1，下方的半月真实值为-1，该数据集生成代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import matplotlib.pyplot as plt
import numpy as np
import random
import math


class SemicircleGenerator(object):
    """docstring for SemicircleGenerator"""

    def __init__(self, StartLocation, RadiusList, Orientation):
        super(SemicircleGenerator, self).__init__()
        self.StartLocation = StartLocation
        self.MaxRadius = max(RadiusList)
        self.MinRadius = min(RadiusList)
        self.Orientation = Orientation

构造函数确定了单月的信息：

  • StartLocation是一个坐标list，表示月原点（圆心）的位置
  • RadiusList是一个存储了大圈的半径和小圈的半径list
  • Orientation表示月的朝向，+表示向上，-表示向下
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def Gen_SemicircleData(self, BatchSize):
        for _ in range(BatchSize):
            Radius = random.uniform(self.MinRadius, self.MaxRadius)
            BiasX = random.uniform(- Radius, Radius)
            BiasY = math.sqrt(Radius * Radius - BiasX * BiasX)
            if self.Orientation == "+":
                yield [BiasX + self.StartLocation[0], BiasY
                       + self.StartLocation[1]]
            else:
                yield [self.StartLocation[0] - BiasX,
                       self.StartLocation[1] - BiasY]
    Gen_SemicircleData()是一个生成器，用于生成指定数量的单月形状内的点，过程是首先使用random.uniform()生成一个半径范围内的随机半径，再生成一个正负半径内的随机x偏移量，通过勾股定理计算出y的偏移量，即可以生成一个落在单月形状内的随机点，再根据朝向生成这个点的绝对坐标使用yield返回

Rosenblatt训练与测试环境

通过调用Rosenblatt和数据集代码生成训练和测试环境，并使用matplotlib绘图实现可视化

1
2
3
4
5
6
7
8
9
from Rosenblatt import Rosenblatt
from SemicircleGenerator import SemicircleGenerator
import numpy as np
import matplotlib.pyplot as plt

neural = Rosenblatt(2)
dataset1 = SemicircleGenerator([0, 0], [4, 6], "+")
dataset2 = SemicircleGenerator([7, -2], [4, 6], "-")
testdata_x, testdata_y = [], []

首先建立神经元和数据集
1
2
3
4
5
6
7
8
for data in dataset1.Gen_SemicircleData(1000):
    neural.TrainOneStep(np.array([data]), 1)
    testdata_x.append(data[0])
    testdata_y.append(data[1])
for data in dataset2.Gen_SemicircleData(1000):
    neural.TrainOneStep(np.array([data]), -1)
    testdata_x.append(data[0])
    testdata_y.append(data[1])

再分别使用数据集进行训练，并保存训练数据
1
2
3
4
5
6
print(neural.Weight)
x_data, y_data = [-6, 13], []
print(neural.Weight[1][0])
for i in x_data:
    y_data.append(- (neural.Weight[0][0] + i *
                     neural.Weight[1][0]) / (neural.Weight[2][0]))

通过训练得到的数据得出结果直线
1
2
3
plt.plot(x_data, y_data, color="red")
plt.scatter(testdata_x, testdata_y)
plt.show()

使用matplotlib绘图，plt.plot()用于绘制折线图，颜色配置可以参考这里，plt.scatter()用于绘制散点图，plt.show()显示已经绘制的图像，更多matplotlib绘图可以参考这里和这里

结果

生成的图像如下：

红线代表感知器的学习结果，可以看到很好的划分出了两个半月之间的界限