深度学习 Rosenblatt感知器

import numpy as np

import matplotlib as mpl
mpl.use('TKAgg')#图形显示的默认方式
import matplotlib.pyplot as plt


def dbmoon(N=1000, d=1, r=10, w=6):#半月数据
    N1 = 10 * N
    w2 = w / 2
    done = True
    data = np.empty(0)
    while done:
        tmp_x = 2 * (r + w2) * (np.random.random([N1, 1]) - 0.5)
        tmp_y = (r + w2) * np.random.random([N1, 1])
        tmp = np.concatenate((tmp_x, tmp_y), axis=1)
        tmp_ds = np.sqrt(tmp_x * tmp_x + tmp_y * tmp_y)

        idx = np.logical_and(tmp_ds > (r - w2), tmp_ds < (r + w2))
        idx = (idx.nonzero())[0]

        if data.shape[0] == 0:
            data = tmp.take(idx, axis=0)
        else:
            data = np.concatenate((data, tmp.take(idx, axis=0)), axis=0)
        if data.shape[0] >= N:
            done = False

    db_moon = data[0:N, :]
    data_t = np.empty([N, 2])
    data_t[:, 0] = data[0:N, 0] + r
    data_t[:, 1] = -data[0:N, 1] - d
    db_moon = np.concatenate((db_moon, data_t), axis=0)
    return db_moon

def show_moon():#半月数据展示
    N = 1000
    d = 1
    r = 10
    w = 6
    data = dbmoon(N, d, r, w)
    plt.plot(data[0:N, 0], data[0:N, 1], 'r*', data[N:2 * N, 0], data[N:2 * N, 1], 'b*')
    plt.show()

def get_title(db_moon,b):#获得标签
    '''
    每一项的第一个数为b（偏置），最后一项为标签，中间数据为向量
    '''
    N = 1000    
    data = []
    for i in range(int(N/2)):#第一类
        data.append([])
        data[i].append(b)    #偏置
        data[i].append(db_moon[0:N, 0][i])
        data[i].append(db_moon[0:N, 1][i])
        data[i].append(-1)
    for i in range(int(N/2),N):#第二类
        data.append([])
        data[i].append(b)
        data[i].append(db_moon[N:2 * N, 0][i-int(N/2)])
        data[i].append(db_moon[N:2 * N, 1][i-int(N/2)])
        data[i].append(1)
    return data

def sgn(v):    ##激活函数
    if v>0:
        return 1
    else:
        return -1

def matrix_multi(ls1,ls2):    #矩阵相乘
    s = 0
    for i in range(len(ls1)):
        s += ls1[i]*ls2[i]
    return s

def Y(w,x):    #实际响应
    return sgn(matrix_multi(w,x))

def Rosenblatt(X):    #X为输入
    a = 0.5    #学习率 0<a<1
    w = [1,0,0]    #权重向量初始化
    for i in range(len(X)):    #自适应
        w_new = [1]
        y = Y(w,X[i][:3])    #实际响应
        for j in range(1,len(w)):
            w_new.append(w[j]+a*(X[i][3]-y)*X[i][j])
        if w==w_new:    #收敛条件
            return w
        w = w_new
    return w

def score(w,X):    #感知器效果
    X_new = []    
    for i in range(len(X)):
        X_new.append(X[i])
        y = Y(w,X[i][:3])    #实际响应
        X_new[i][-1] = y
    data1 = []
    data2 = []
    for i in range(len(X_new)):
        if X_new[i][-1] == -1:
            data1.append(X_new[i][:-1])
        else:
            data2.append(X_new[i][:-1])
    data1 = np.array(data1)
    data2 = np.array(data2)
    plt.plot(data1[0:len(data1), 1], data1[0:len(data1), 2], 'r*', data2[0:len(data2), 1], data2[0:len(data2), 2], 'b*')
    plt.show()
    return X_new

if __name__ == "__main__":
    db_moon = dbmoon()
    print("训练数据：")
    show_moon()
    b = 1    #偏置
    data = get_title(db_moon,b)
    #print(len(data),data[0])
    w = Rosenblatt(data)
    print("测试数据：")
    score(w,data)