BP神经网络用于Iris数据集的分类

　　全连接神经网络BP算法的原理在此不再赘述了，网上有大量的资料可以参考，我就直接贴代码：（用着还行的，帮忙点个推荐啊）

# _*_ coding:utf-8 _*_
import numpy as np
import matplotlib.pyplot as plt
import math

#学习率
LearnRate = 0.1
#迭代次数最小值
start_num = 100
#迭代次数最大值
stop_num = 1100
#步长
step_num = 100
#误差隔多少次迭代输出
int_con = 100
#是否输出每次学习的测试结果
input_predict = False
#是否优化
better = True



#get data
def getdata(num):
    
    file1 = np.loadtxt("Iris666.txt", dtype=np.str, delimiter=' ')
    x_tr = file1[0:,0:4].astype(np.float)
    y_tr = file1[0:,4].astype(np.float)
    y_tr = y_tr.reshape(75,1)

    file2 = np.loadtxt("Iris-test.txt",dtype=np.str,delimiter= ' ')
    x_te = file2[0:,0:4].astype(np.float)
    y_te = file2[0:,4].astype(np.float)
    y_te = y_te.reshape(75,1)
    if num==1:
        return x_tr.T,y_tr.T
    elif num==0:
        return x_te.T,y_te.T
    else:
        print("wrong!\n")

#层数可以改变
def layer_size(X, Y):
    dim_input = X.shape[0]
    dim_label = Y.shape[0]
    return (dim_input, dim_label)


#随机初始化一个W1,b1,b2,W2矩阵
def initialize_parameters(dim_input, dim_label):
    W1 = np.random.randn(10, dim_input) * 0.01
    b1 = np.zeros((10, 1))
    W2 = np.random.randn(dim_label, 10) * 0.01
    b2 = np.zeros((dim_label, 1))

    parameters = {
        'W1': W1,
        'b1': b1,
        'W2': W2,
        'b2': b2,
    }
    return parameters

#sigmoid函数
def sigmoid_normalized(z):
        return 1.0 / (1.0 + np.exp(-z))

#正向传播
def forward_propagation(X, parameters):
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']

    y1 = sigmoid_normalized(np.dot(W1, X) + b1)
    y2 = sigmoid_normalized(np.dot(W2, y1) + b2)


    mid_data = {
        'y1': y1,
        'y2': y2,
    }

    return y2, mid_data

#损失函数
def compute_cost(y2, Y, parameters):

    m = Y.shape[1]  # number of example

    W1 = parameters['W1']
    W2 = parameters['W2']

    cost = np.sum(np.multiply((Y- y2), (Y-y2)))/2
    cost = np.squeeze(cost)

    return cost

#反向传播学，梯度生成
def backward_propagation(parameters, mid_data, X, Y):
    m = X.shape[1]

    W1 = parameters['W1']
    W2 = parameters['W2']

    y1 = mid_data['y1']
    y2 = mid_data['y2']

    dW2 = np.dot(np.multiply(np.multiply(y2,1.-y2),y2 - Y), y1.T)
    db2 = np.multiply(np.multiply(y2,1.-y2),y2 - Y)
    dW1=np.dot(np.multiply(np.multiply(y1, 1. - y1),np.multiply(np.multiply(y2,1.-y2),y2 - Y)),X.T)
    db1 = np.multiply(np.multiply(y1, 1. - y1), np.multiply(np.multiply(y2, 1. - y2), y2 - Y))

    SDG = {
        'dW1': dW1,
        'db1': db1,
        'dW2': dW2,
        'db2': db2,
    }

    return SDG

#更新参数，更新模型
def update_para(parameters, SDG, learning_rate):
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']

    dW1 = SDG['dW1']
    db1 = SDG['db1']
    dW2 = SDG['dW2']
    db2 = SDG['db2']

    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2

    parameters = {
        "W1": W1,
        "b1": b1,
        "W2": W2,
        "b2": b2,
    }

    return parameters

#神经网络
def nerual_network(X, Y, num_iterations, learning_rate):
    dim_input = layer_size(X, Y)[0]
    dim_label = layer_size(X, Y)[1]

    parameters = initialize_parameters(dim_input, dim_label)
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']

    cost_list = []
    for i in range(0, num_iterations):

        y2, mid_data = forward_propagation(X, parameters)
        cost = compute_cost(y2, Y, parameters)
        cost_list.append(cost)
        SDG = backward_propagation(parameters, mid_data, X, Y)
        parameters = update_para(parameters, SDG, learning_rate)
        if (i %  int_con== 0) and (i <= 5000):
            print("经过%i次迭代，误差为: %f" % (math.floor(i/int_con)*int_con, cost))

    return parameters, cost_list


def main():

    if better:
        a = ((sigmoid_normalized(1)- sigmoid_normalized(0))/(sigmoid_normalized(0) + sigmoid_normalized(1)))*sigmoid_normalized(0)
        b = ((sigmoid_normalized(2) - sigmoid_normalized(1)) / (sigmoid_normalized(2) + sigmoid_normalized(
            1))) * sigmoid_normalized(1)
    #训练集
    X, Y = getdata(1)
    X = sigmoid_normalized(X)
    Y = sigmoid_normalized(Y)
    correct = []
    for j in range(start_num,stop_num,step_num):
        parameter, cost_list = nerual_network(X, Y, num_iterations=j, learning_rate=LearnRate)

        #测试
        X1,Y1 = getdata(0)
        X1 = sigmoid_normalized(X1)
        y2, mid_data = forward_propagation(X1,parameters=parameter)
        if input_predict:
            print(y2)
        Label = y2
        if better:
            x1=sigmoid_normalized(1)+b
            x2=sigmoid_normalized(0)+a
            Label[Label > x1] = 2
            Label[Label <x2 ] = 0
            Label[(Label >= x2) & (Label <= x1)] = 1
        else:
            Label[Label >= sigmoid_normalized(2)] = 2
            Label[Label <= sigmoid_normalized(0)] = 0
            Label[(Label > sigmoid_normalized(0)) & (Label < sigmoid_normalized(2))] = 1
        if input_predict:
            print(Label)
            print(Y1)
        count = 0
        for i in range(0, 75):
            if Label[0, i] == Y1[0, i]:
                count += 1
        correct.append((100 * count / 75))
        #print(y2)
        #print(Y1)
        #plt.plot(cost_list)
         #plt.show()

    print('平均准确率：%f \n'%(np.mean(correct)))
    plt.figure()
    plt.plot(correct)
    plt.figure()
    plt.plot(cost_list)
    plt.show()

if __name__ == '__main__':
    main()

    '''结果：
            未优化：
                迭代大于1000后稳定在61%左右
                小于一千是优化效果明显
            优化：
                50次以上，》=91%（人工优化，邻近加权分区）
    '''