基于双月数据集利用感知层进行分类

1、生成数据集

class moon_data_class(object):
    def __init__(self,N,d,r,w):
        self.N=N
        self.w=w
      
        self.d=d
        self.r=r
    
   
    def sgn(self,x):
        if(x>0):
            return 1;
        else:
            return -1;
    
        
    def dbmoon(self):
        N1 = 10*self.N
        r = self.r
        w2 = self.w/2
        d = self.d
        done = True
        data = np.empty(0)
        while done:
            #generate Rectangular data
            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)
            #generate double moon data ---upper
            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
        #print (data)
        db_moon = data[0:N, :]
        #print (db_moon)
        #generate double moon data ----down
        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
N = 1000
d = 3
r = 10
width = 2

data_source = moon_data_class(N, d, r, width)
data = data_source.dbmoon()

2、整理数据集，将输入数据定义为感知器的标准输入，将数据集分为1和-1两类，存入列表d中。

x0 = [1 for x in range(1,2001)]#固定为+1
x =  np.array([np.reshape(x0, len(x0)), np.reshape(data[0:2*N, 0], len(data)), np.reshape(data[0:2*N, 1], len(data))]).transpose()
w = np.array([1, 0, 0])

d_pre = [1 for y in range(1, 1001)]
d_pos = [-1 for y in range(1, 1001)]
d=d_pre+d_pos

3、迭代训练获取权值向量

for ii in range(50):
    i=0
    sum = 0
    for x_n in x:
        y_n = data_source.sgn(np.dot(w.T, x_n))
        w = w + a*(d[i] - y_n)*x_n
        i = i+1

4、计算决策边界，绘制训练结果。
因为
$$w[0]+w[1]\ast x+w[2]\ast y=0$$
于是有
$$y=-w[1]/w[2]\ast x-w[0]/w[2]$$

x = np.array(range(-15, 25))
y = -x*w[1]/w[2]-w[0]/w[2]

plt.subplot(211)
plt.plot(x, y, 'g--')

plt.plot(data[0:N, 0], data[0:N, 1], 'r*', data[N:2*N, 0], data[N:2*N, 1], 'b*')
plt.show()

5、运行结果