可以多分类的神经网络

'''
11行神经网络① 
层数可变，多类
'''
import numpy as np
import matplotlib.pyplot as plt



class BPNN(object):
    def __init__(self, neurals, epsilon=0.01, lamda=0.01):
        if not isinstance(neurals, list): raise '出错：参数 neurals 必须是 list 类型'
        self.neurals = neurals   # 各层神经元数目，如：[3,10,8,2]
        self.size = len(neurals)
        
        self.epsilon = epsilon  # 学习速率
        self.lamda = lamda      # 正则化强度

        self.w = [np.random.randn(i,j) for i,j in zip(neurals[:-1], neurals[1:])] + [None]
        self.b = [None] + [np.random.randn(1,j) for j in neurals[1:]]
        self.l = [None] * self.size
        self.l_delta = [None] * self.size
        
        self.probs = None
        
    # 前向传播
    def forward(self, X):
        self.l[0] = X
        for i in range(1, self.size-1):
            self.l[i] = np.tanh(np.dot(self.l[i-1], self.w[i-1]) + self.b[i]) # tanh 函数    
        self.l[-1] = np.exp(np.dot(self.l[-2], self.w[-2]) + self.b[-1])
        self.probs = self.l[-1] / np.sum(self.l[-1], axis=1, keepdims=True)
        
    # 后向传播
    def backward(self, y):
        self.l_delta[-1] = np.copy(self.probs)
        self.l_delta[-1][range(self.n_samples), y] -= 1
        for i in range(self.size-2, 0, -1):
            self.l_delta[i] = np.dot(self.l_delta[i+1], self.w[i].T) * (1 - np.power(self.l[i], 2)) # tanh 函数的导数
            
    # 更新权值、偏置
    def update(self):
        self.b[-1] -= self.epsilon * np.sum(self.l_delta[-1], axis=0, keepdims=True)
        for i in range(self.size-2, -1, -1):
            self.w[i] -= self.epsilon * (np.dot(self.l[i].T, self.l_delta[i+1]) + self.lamda * self.w[i])
            if i == 0: break
            self.b[i] -= self.epsilon * np.sum(self.l_delta[i], axis=0)
    
    # 计算损失
    def calculate_loss(self, y):
        loss = np.sum(-np.log(self.probs[range(self.n_samples), y]))
        loss += self.lamda/2 * np.sum([np.sum(np.square(wi)) for wi in self.w[:-1]]) # 可选
        loss *= 1/self.n_samples  # 可选
        return loss
    
    # 拟合
    def fit(self, X, y, n_iter=1000, print_loss=True):
        self.n_samples = X.shape[0] # 样本大小（样本数目）
        
        for i in range(n_iter):
            self.forward(X)
            self.backward(y)
            self.update()
            
            if not print_loss: continue
            if i%100 == 0: print(self.calculate_loss(y))
    
    # 预测
    def predict(self, x):
        self.forward(x)
        return np.argmax(self.probs, axis=1)
    

    
def plot_decision_boundary(clf, X, y):
    # Set min and max values and give it some padding
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    h = 0.01
    # Generate a grid of points with distance h between them
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    # Predict the function value for the whole gid
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    # Plot the contour and training examples
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
    
    
def test1():
    X = np.array([[0,0,1],[0,1,1],[1,0,1],[1,1,1]])
    #y = np.array([0,1,1,0]) # 两类
    y = np.array([0,1,2,3])  # 多类
    
    # bpnn = BPNN([3, 10, 8, 1])
    bpnn = BPNN([3, 10, 8, 4])
    bpnn.fit(X, y, n_iter=1000)
    
    print('训练结果：', bpnn.predict(X))
    
    
def test2():
    from sklearn.datasets import make_moons
    from sklearn.linear_model import LogisticRegressionCV
    
    X, y = make_moons(200, noise=0.20)
    plt.scatter(X[:,0], X[:,1], s=40, c=y, cmap=plt.cm.Spectral)
    plt.show()

    clf = LogisticRegressionCV()
    clf.fit(X, y)
    plot_decision_boundary(clf, X, y)
    plt.show()

    #nn = BPNN([2,5,4,2])
    nn = BPNN([2,4,2])
    nn.fit(X, y, n_iter=1000)
    plot_decision_boundary(nn, X, y)
    plt.show()
    
    
    
if __name__ == '__main__':
    #test1()
    test2()