基于BP神经网络的模式识别

118页pdf实验数据：

phttp://file:///D:/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD%E5%AE%9E%E9%AA%8C/BP%E5%AF%B9%E6%AF%94%E6%95%B0%E6%8D%AE/BP%E5%AE%9E%E9%AA%8C%E6%95%B0%E6%8D%AE%E8%A1%A8.pdf

 数据处理代码

import copy
import matplotlib.pyplot as plt
from matplotlib import font_manager

import numpy as np
from math import *


# 第一部分 初始化参数和训练集
def init(choose):
    if choose:
        return np.random.randn(63, hid_node).tolist()
    else:
        return np.random.randn(hid_node, 10).tolist()


def f(x):
    global aref
    return 1 / (1 + exp(-aref * x))


def calculate_out():  # 记得初始化layin的第一层就是输入
    global layer_out
    for i in range(len(layer_out)):
        if i != 0:
            layer_in[i] = np.dot(np.asarray(layer_out[i - 1]), np.asarray(weight[i])).tolist()
        for j in range(len(layer_out[i])):
            layer_out[i][j] = f(layer_in[i][j])
    # for i in range(len(layer_out[-1])):
    #     if layer_out[-1][i] < 0.1:
    #         layer_out[-1][i] = 0
    #     elif layer_out[-1][i] > 0.9:
    #         layer_out[-1][i] = 1


def check(num):
    global layer_out
    # 匹配每一个数字
    sum = 0
    for out in range(10):
        if out == num:
            sum += (layer_out[-1][out] - 1) * (layer_out[-1][out] - 1)
        else:
            sum += layer_out[-1][out] * layer_out[-1][out]
    return sum / 2


def f_derivative(x):
    return f(x) * (1 - f(x))


def find_di(j, k, num):
    if k == len(layer_out) - 1:
        if num == j:
            exp = 1
        else:
            exp = 0
        di = (layer_out[k][j] - exp) * f_derivative(layer_in[k][j])
    else:
        di = 0
        for i in range(len(layer_out[k + 1])):
            di += find_di(i, k + 1, num) * weight[k + 1][j][i]
        di *= f_derivative(layer_in[k][j])
    return di


def train(num):
    for k in range(1, len(weight)):
        for i in range(len(weight[k])):
            for j in range(len(weight[k][i])):
                di_k = find_di(j, k, num)
                weight_di[k][i][j] += -kesi * di_k * layer_out[k - 1][i]


def input_fir_lay(choose, train_num, test_num):
    global layer_in
    if choose == 0:
        if train_num == 0:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 1:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1,1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 2:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 3:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 4:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 5:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 6:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 7:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 8:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        elif train_num == 9:
            input_data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,0]
        else:
            input_data = []
    else:
        input_data = copy.deepcopy(test_num)
    layer_in[0] = copy.deepcopy(input_data)


def write_loss():
    global kesi
    global hid_node
    global avg_all_lose
    global possible_right
    file = open(add_loss, 'a')
    file.writelines("当前隐藏层神经元个数={}，kesi={}   ".format(hid_node,kesi))
    sum_loss = 0
    sum_right = 0
    for i in range(len(avg_all_lose)):
        sum_loss += avg_all_lose[i]
        sum_right += possible_right[i]
        file.writelines(str(avg_all_lose[i])+" ")
    file.writelines(str(sum_loss/len(avg_all_lose))+" "+str(sum_right /len(possible_right)) + "\n")
    print("avg_all_loss:", sum_loss/len(avg_all_lose))
    file.close()


def write_output(min_num):
    global kesi
    global hid_node
    global layer_out
    global weight
    file = open(add_output.format(kesi,hid_node), 'a')
    file.writelines(str(min_num) + " ")
    for i in layer_out[len(layer_out)-1]:
        file.writelines(str(i) + " ")
    file.writelines("\n\n")
    file.close()


def change_weight():
    global weight
    global weight_di
    for k in range(1, len(weight)):
        for i in range(len(weight[k])):
            for j in range(len(weight[k][i])):
                weight[k][i][j] += weight_di[k][i][j] / 10
    weight_di = [[], [[0 for _ in range(hid_node)] for _ in range(63)], [[0 for _ in range(10)] for _ in range(hid_node)]]

#########判断是否开始第一次震荡
# def judge_zhendang(avg_all_lose,times,times_copy):
#     global kesi
#     num = len(avg_all_lose) - 1  # 最新的一个平均损失
#     if avg_all_lose[num] > avg_all_lose[num - 1]:
#         kesi = kesi / 1.5
#         print("已开始震荡！！！！！，此时迭代次数为",times_copy - times)
#         print("修改后的学习率为：",kesi)
#         return 1


def iter(times):
    times_copy = times
    global kesi
    global avg_all_lose
    sum_all_lose = 0
    while times:
        for train_num in range(10):
            input_fir_lay(0, train_num, [])
            calculate_out()
            train(train_num)
            # if times == 1:
            sum_all_lose += check(train_num)
        times -= 1
        change_weight()
        avg_all_lose.append(sum_all_lose / 10)
        print("avg_all_lose:",sum_all_lose / 10,"times:",times_copy - times)
        sum_all_lose = 0


# def input_weight(train_num):
#     global weight
#     for k in range(1, len(weight)):
#         weight[k] = copy.deepcopy(np.loadtxt(add.format(train_num, k)).tolist())


def test(test_num,test_number):
    global right
    global xiuzheng_right
    min_e = Info
    min_num = -1
    # input_weight(3)
    for num in range(10):
        input_fir_lay(1, [], test_num)
        calculate_out()
        check_num = check(num)
        # ########################  change
        # input_fir_lay(0,num,[])
        # calculate_out()
        # check_std = check(num)
        # loss =
        # #######################
        if check_num < min_e:
            min_num = num
            min_e = check_num
    if min_num == test_number:
        right += 1
    if test_number == 8 and min_num == 6:
        xiuzheng_right = 1
    print(min_num)
    write_output(min_num)

test_num_list = [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
times = 1500
times_copy_paint = times
aref = 1
e = 0.1 * 0.1 * 10 / 2
hide_node_list = [16,17,18]
kesi_list = [5, 5.5, 6, 6.5, 7, 7.5, 8]
Info = 1e10
add_output = r"D:\人工智能\bp数据\kesi={}，hid_node={}的十次输出"
add_loss = r"D:\人工智能\bp数据\loss及平均"
# for hid_node in hide_node_list:
#     for kesi in kesi_list:
#         possible_right = []
#         avg_all_lose = []
#         for _ in range(10):
#             layer_out = [[0 for _ in range(63)], [0 for _ in range(hid_node)], [0 for _ in range(10)]]
#             layer_in = [[0 for _ in range(63)], [0 for _ in range(hid_node)], [0 for _ in range(10)]]
#             weight = [[], init(1), init(0)]
#             weight_di = [[], [[0 for _ in range(hid_node)] for _ in range(63)],[[0 for _ in range(10)] for _ in range(hid_node)]]
#             iter(times)
#             right = 0
#             for test_number in range(len(test_num_list)):
#                 test(test_num_list[test_number],test_number)
#             possible_right.append(right / 10)
#         write_loss()

hid_node = 17
kesi = 5
possible_right = []
avg_all_lose = []
layer_out = [[0 for _ in range(63)], [0 for _ in range(hid_node)], [0 for _ in range(10)]]
layer_in = [[0 for _ in range(63)], [0 for _ in range(hid_node)], [0 for _ in range(10)]]
weight = [[], init(1), init(0)]
weight_di = [[], [[0 for _ in range(hid_node)] for _ in range(63)],[[0 for _ in range(10)] for _ in range(hid_node)]]
iter(times)
right = 0
xiuzheng_right = 0
for test_number in range(len(test_num_list)):
    test(test_num_list[test_number],test_number)
print("修正前的正确率为：{}%".format(right/10*100))
print("修正后的正确率为：{}%".format((right+xiuzheng_right)/10*100))

#
# times = eval(input("输入你的迭代次数："))
##########绘图
x=list(range(times_copy_paint))
y=avg_all_lose
my_font = font_manager.FontProperties(fname='simfang.ttf')
plt.plot(x,y) #画图，自变量x放前面
plt.grid(alpha=0.3, linestyle='-.')
xticks_labels = ["第{}次".format(a) for a in x]
plt.xlabel('迭代次数', fontproperties=my_font)
plt.ylabel('平均损失', fontproperties=my_font)
plt.show()
##########绘图


# test_num = eval(input("请输入你的测试数据：(用一个列表的形式按顺序输入)"))
# test(test_num)
#
# x_loss = [5, 5.5, 6, 6.5, 7, 7.5, 8]
# y_loss1 = [0.00833, 0.00518, 0.01824, 0.02321, 0.00455, 0.09380, 0.14925 ]
# y_loss2 = [0.00366, 0.00485, 0.01466, 0.09034, 0.07098, 0.04521, 0.29667 ]
# y_loss3 = [0.00418, 0.00534, 0.00356, 0.01379, 0.08198, 0.15200, 0.30099 ]
# my_font = font_manager.FontProperties(fname='simfang.ttf')
# plt.figure(figsize=(10, 8), dpi=90)
# xticks_labels = ["kesi = {}".format(a) for a in x_loss]
# plt.grid(alpha=0.3, linestyle='-.')
# plt.plot(x_loss, y_loss1, label='hide_node = 16', linewidth=3, color='r', alpha=0.5, linestyle='--') #
# plt.plot(x_loss, y_loss2, label='hide_node = 17', linewidth=2,linestyle=':', color='green')
# plt.plot(x_loss, y_loss3, label='hide_node = 18', linewidth=1.5,linestyle='-.', color='blue')
# plt.legend(loc='upper left')
# plt.xticks(x_loss[::1], labels=xticks_labels, rotation=45, fontproperties=my_font)
# plt.title('不同参数十次运行的平均loss折线图', fontproperties=my_font)
# plt.xlabel('不同kesi值', fontproperties=my_font)
# plt.ylabel('平均loss值', fontproperties=my_font)
# plt.show()

数据自动化录入pdf代码

from docx import Document

add = 'D:/人工智能实验/BP实验数据表.docx'
doc = Document()
hid_node = ["16", "17", "18"]
kesi = ["5", "5.5", "6", "6.5", "7", "7.5", "8"]
with open("D:\人工智能实验\\bp测试数据/loss及平均", "r", encoding="UTF-8") as file:
    cont = file.readlines()
ls_loss = []
for line in cont:
    ls_loss.append(line.rstrip().split())

###################################################
doc.add_paragraph("")
doc.add_paragraph("这是对应参数10次loss的平均值")
doc.add_paragraph("")
##################################################
table_list = []
table_list.append([""] + kesi)
for j in range(3):
    ls = []
    ls.append(hid_node[j])
    for i in range(j * len(kesi), (j + 1) * len(kesi)):
        ls.append("{:.5f}".format(eval(ls_loss[i][-2])))
    table_list.append(ls)
row1 = len(hid_node)
col1 = len(kesi)
table = doc.add_table(row1 + 1, col1 + 1, style="Table Grid")
for i in range(len(hid_node) + 1):
    for j in range(len(kesi) + 1):
        table.cell(i, j).text = table_list[i][j]

#################################################################
doc.add_paragraph("")
doc.add_paragraph("这是对应参数十次运算的平均正确率")
doc.add_paragraph("")
####################### ##########################################
table_list = []
table_list.append([""] + kesi)
for j in range(3):
    ls = []
    ls.append(hid_node[j])
    for i in range(j * len(kesi), (j + 1) * len(kesi)):
        ls.append("{:.3f}%".format(eval(ls_loss[i][-1])*100))
    table_list.append(ls)
table = doc.add_table(row1 + 1, col1 + 1, style="Table Grid")
for i in range(len(hid_node) + 1):
    for j in range(len(kesi) + 1):
        table.cell(i, j).text = table_list[i][j]


###################################
ls_last = []
row2 = 13 * 10
col2 = 12
ls_title = ["", "结点", "1次", "2次", "3次", "4次", "5次", "6次", "7次", "8次", "9次", "10次"]
for i in hid_node:
    ls_last_line =[]
    for j in kesi:
        doc.add_paragraph("")
        doc.add_paragraph("隐藏层的个数是{}，学习率为{}".format(i, j))
        doc.add_paragraph("")
        table = doc.add_table(row2, col2, style="Table Grid")
        with open("D:\人工智能实验\\bp测试数据\kesi={}，hid_node={}的十次输出".format(j, i), "r", encoding="UTF-8") as file:
            cont = file.readlines()
        ls = []
        for line in cont:
            ll = line.rstrip().split()
            if ll:
                ls.append(line.rstrip().split())
        for nums in range(10):
            for col in range(col2):
                table.cell(nums * 13, col).text = ls_title[col]
            table.cell(nums * 13 + 1, 0).text = str(nums)
            for row in range(nums * 13 + 1, nums * 13 + 11):
                table.cell(row, 1).text = str((row % 13)-1)
            for col in range(2, 12):
                for row in range(nums * 13 + 1, nums * 13 + 11):
                    table.cell(row, col).text = "{:.6f}".format(eval(ls[nums+(col - 2) * 10][row % 13]))
            table.cell(11 + nums * 13, 1).text = "结果"
            for col in range(10):
                table.cell(11 + nums * 13, col + 2).text = ls[nums + col * 10][0]
            table.cell(nums * 13 + 1, 0).merge(table.cell(nums * 13 + 11, 0))
            table.cell(nums * 13 + 12, 0).merge(table.cell(nums * 13 + 12, 11))
        doc.add_paragraph("")
        right = 0
        for line in range(len(ls)):
            if ls[line][0] == str(line%10):
                right += 1
            else:
                if ls[line][0] == '6' and str(line%10) == '8':
                    right += 1
        ls_last_line.append(str(right/len(ls)))
    ls_last.append(ls_last_line)

#################################################################
doc.add_paragraph("")
doc.add_paragraph("这是对应参数十次运算的修正平均正确率")
doc.add_paragraph("")
####################### ##########################################
table_list = []
table_list.append([""] + kesi)
for j in range(len(hid_node)):
    ls = []
    ls.append(hid_node[j])
    for i in range(len(kesi)):
        ls.append("{:.3f}%".format(eval(ls_last[j][i])*100))
    table_list.append(ls)
table = doc.add_table(row1 + 1, col1 + 1, style="Table Grid")
for i in range(len(hid_node) + 1):
    for j in range(len(kesi) + 1):
        table.cell(i, j).text = table_list[i][j]

doc.save(add)