|
|
# coding = UTF-8
|
|
|
import os
|
|
|
import sys
|
|
|
import pickle
|
|
|
import subprocess
|
|
|
import functools
|
|
|
import numpy as np
|
|
|
import pandas as pd
|
|
|
import tkinter as tk
|
|
|
from tkinter import ttk
|
|
|
from tkinter import messagebox
|
|
|
import tkinter.scrolledtext as st
|
|
|
from PIL import Image, ImageTk
|
|
|
from tkinter import Canvas, Frame, BOTH, PhotoImage, filedialog
|
|
|
from X3 import setload_data,load_data
|
|
|
from X2 import ModelObj
|
|
|
# 网络模型正确的图元和连接关系的数据结构，用一个字典表示
|
|
|
RIGHT_MODEL = [
|
|
|
[0, 1, 0, 0, 0, 0, 0, 0, 0],
|
|
|
[0, 0, 1, 0, 0, 0, 0, 0, 0],
|
|
|
[0, 1, 0, 1, 0, 0, 0, 0, 0],
|
|
|
[0, 0, 0, 1, 1, 0, 0, 0, 0],
|
|
|
[0, 0, 0, 0, 0, 1, 0, 0, 0],
|
|
|
[0, 0, 0, 0, 0, 0, 1, 0, 0],
|
|
|
[0, 0, 0, 0, 0, 0, 0, 1, 1],
|
|
|
[0, 1, 0, 0, 0, 0, 0, 0, 0],
|
|
|
[0, 0, 0, 1, 0, 0, 0, 0, 0]
|
|
|
]
|
|
|
|
|
|
# 创建三个空的卷积层图元实例和三个空的全连接层图元实例
|
|
|
Conv1 = None
|
|
|
Conv2 = None
|
|
|
Conv3 = None
|
|
|
Pool1 = None
|
|
|
Pool2 = None
|
|
|
Pool3 = None
|
|
|
Fullconn1 = None
|
|
|
Fullconn2 = None
|
|
|
Fullconn3 = None
|
|
|
|
|
|
global Viewcanvas # 定义画布
|
|
|
global Text # 带滚动条
|
|
|
global Root # 主窗口
|
|
|
global AllModelObj #网络对象
|
|
|
|
|
|
List_image = [] # 存储图元的列表
|
|
|
Prob_images = [] # 存储图元的列表
|
|
|
Train_images = [] # 存储训练集的列表
|
|
|
Test_images = [] # 存储测试集的列表
|
|
|
Items1 = [] # 存储新图元的列表
|
|
|
Items2 = [] # 存储新数据线的列表
|
|
|
Items3 = [] # 存储被拖拽的图元的列表
|
|
|
Items4 = [] # 存储新图元文字标签的列表
|
|
|
Counts = {} # 用来存储Items3每个数字出现过的次数
|
|
|
Conv_xy_list = [] # 存储卷积图元的坐标
|
|
|
Pool_xy_list = [] # 存储全连接图元的坐标
|
|
|
Fullconn_xy_list = [] # 存储全连接图元的坐标
|
|
|
Train_list = [] # 存储训练设置参数
|
|
|
Listinstance = [] # 图元对象实例
|
|
|
Dragged_item = () # 记录被拖拽的图元id
|
|
|
Original_x = 0 # 记录图元原来的x坐标
|
|
|
Original_y = 0 # 记录图元原来的y坐标
|
|
|
Offset_x = 0 # 记录鼠标相对于图元的x偏移量
|
|
|
Offset_y = 0 # 记录鼠标相对于图元的y偏移量
|
|
|
Yt = 0 # 新图元的y坐标
|
|
|
Batch = 0 #批次
|
|
|
|
|
|
def create_instance():
|
|
|
# 创建图元对象实例
|
|
|
DataSet = ModelObj("DataSet", 1, "数据集", "LoadData", "SetDataPara", ".", 90, 40).output()
|
|
|
Conv = ModelObj("Conv", 2, "卷积", "ConvProc", "SetConvPara", ".", 200, 40).output()
|
|
|
Pool = ModelObj("Pool", 3, "最大池化", "MaxPoolProc", "SetPollPara", ".", 90, 105).output()
|
|
|
FullConn = ModelObj("FullConn", 4, "全连接", "FullConnProc", "SetFullConnPara", ".", 200, 105).output()
|
|
|
Nonline = ModelObj("Nonline", 5, "非线性函数", "NonlinearProc", "SetNonLPara", ".", 90, 170).output()
|
|
|
Classifier = ModelObj("Classifier", 6, "分类", "ClassifierProc", "SetClassifyPara", ".", 200, 170).output()
|
|
|
Error = ModelObj("Error", 7, "误差计算", "ErrorProc", "SetErrorPara", ".", 90, 235).output()
|
|
|
AjConv = ModelObj("AjConv", 8, "卷积调整", "AjConvProc", "SetAjConvPara", ".", 200, 235).output()
|
|
|
AjFullconn = ModelObj("AjFullconn", 9, "全连接调整", "AjFullconnProc", "SetAjFCPara", ".", 90, 300).output()
|
|
|
AjNonline = ModelObj("AjNonline", 10, "非线性调整", "AjNonlineProc", "SetAjNLPara", ".", 200, 300).output()
|
|
|
listinstance = [DataSet, Conv, Pool, FullConn, Nonline, Classifier, Error, AjConv, AjFullconn, AjNonline]
|
|
|
return listinstance # 还回图元对象实例列表
|
|
|
|
|
|
def picture_frame(window_width,window_height):
|
|
|
gap = 20 # 设置矩形框之间的间隔为10像素
|
|
|
# 计算矩形框的坐标和尺寸
|
|
|
rect1_x = gap # 第一个矩形框的左上角x坐标
|
|
|
rect1_y = gap # 第一个矩形框的左上角y坐标
|
|
|
rect1_width = window_width * 1 / 3 - gap-30 # 第一个矩形框的宽度
|
|
|
rect1_height = window_height * 3 / 4 - gap * 2 # 第一个矩形框的高度
|
|
|
rect2_x = window_width * 1 / 3 + gap - 30 # 第二个矩形框的左上角x坐标
|
|
|
rect2_y = gap # 第二个矩形框的左上角y坐标
|
|
|
rect2_width = window_width * 2 / 3 - gap + 30 # 第二个矩形框的宽度
|
|
|
rect2_height = window_height * 3 / 4 - gap * 2 # 第二个矩形框的高度
|
|
|
rect3_x = gap # 第三个矩形框的左上角x坐标
|
|
|
rect3_y = window_height * 3 / 4 + gap # 第三个矩形框的左上角y坐标
|
|
|
rect3_width = window_width - gap * 2 # 第三个矩形框的宽度
|
|
|
rect3_height = window_height * 1 / 4 - gap * 2 # 第三个矩形框的高度
|
|
|
global Viewcanvas
|
|
|
# 创建一个画布，用于绘制矩形框，设置画布的大小和背景色
|
|
|
Viewcanvas = tk.Canvas(Root, width=window_width, height=window_height, bg="white")
|
|
|
Viewcanvas.pack() # 将画布添加到主窗口中
|
|
|
# 绘制矩形框，使用不同的颜色和线宽，指定矩形框的左上角和右下角坐标，填充色，边框色和边框宽度
|
|
|
Viewcanvas.create_rectangle(rect1_x, rect1_y, rect1_x + rect1_width, rect1_y + rect1_height,
|
|
|
fill=None, outline="lightblue", width=2)
|
|
|
Viewcanvas.create_rectangle(rect2_x, rect2_y + 20, rect2_x + rect2_width - 20, rect2_y + rect2_height,
|
|
|
fill=None, outline="lightblue", width=2)
|
|
|
Viewcanvas.create_rectangle(rect3_x, rect3_y, rect3_x + rect3_width, rect3_y + rect3_height,
|
|
|
fill=None, outline="lightblue", width=2)
|
|
|
global Text
|
|
|
Text = st.ScrolledText(Root) # 创建一个带滚动条的文本框，用于展示计算过程
|
|
|
Text.place(x=rect3_x, y=rect3_y, width=760, height=rect3_height - 1)
|
|
|
# if __name__ == '__main__':
|
|
|
# Root = tk.Tk()
|
|
|
# # 设置窗口的大小为1200*750
|
|
|
# window_width = 1200 # 窗口的宽度
|
|
|
# window_height = 750 # 窗口的高度
|
|
|
# Root.title("神经网络可视化")
|
|
|
# Root.geometry("1200x750") # 设置窗口的大小和位置
|
|
|
# picture_frame(window_width, window_height)
|
|
|
# Root.mainloop()
|
|
|
|
|
|
def element(path):
|
|
|
# 加载图元对应的图片文件
|
|
|
img=Image.open(path)
|
|
|
# 使用resize方法调整图片
|
|
|
img = img.resize((40, 30))
|
|
|
# 把Image对象转换成PhotoImage对象
|
|
|
img = ImageTk.PhotoImage(img)
|
|
|
# 保存图片的引用，防止被垃圾回收
|
|
|
Root.img = img
|
|
|
return img
|
|
|
|
|
|
def push_button():
|
|
|
button = {}
|
|
|
style = ttk.Style(Root)
|
|
|
# 设置blue.TButton样式
|
|
|
style.configure("blue.TButton", background="LightSlateGray", foreground="black", font=("黑体", 8))
|
|
|
style.map("blue.TButton", background=[('active', 'PowderBlue'), ('pressed', 'red')],
|
|
|
foreground=[('active', 'black'), ('pressed', 'white')])
|
|
|
|
|
|
# 设置green.TButton样式
|
|
|
style.configure("green.TButton", background="MediumSeaGreen", foreground="black", font=("黑体", 8))
|
|
|
style.map("green.TButton", background=[('active', 'PaleGreen'), ('pressed', 'red')],
|
|
|
foreground=[('active', 'black'), ('pressed', 'white')])
|
|
|
|
|
|
# 创建三个按钮，用于触发训练参数的设置、训练、输出模型程序的操作
|
|
|
button1 = ttk.Button(Root, text=" 训练参数设置 ", style="blue.TButton")
|
|
|
button1.place(x=20, y=330)
|
|
|
button['button1'] = button1
|
|
|
button2 = ttk.Button(Root, text=" 训练 ", style="blue.TButton")
|
|
|
button2.place(x=140, y=330)
|
|
|
button['button2'] = button2
|
|
|
button3 = ttk.Button(Root, text=" 输出模型程序 ", style="blue.TButton")
|
|
|
button3.place(x=240, y=330)
|
|
|
button['button3'] = button3
|
|
|
# 创建五个按钮，用于触发操作
|
|
|
button4 = ttk.Button(Root, text=" 加载已有模型 ", style="green.TButton")
|
|
|
button4.place(x=255, y=10)
|
|
|
button['button4'] = button4
|
|
|
button5 = ttk.Button(Root, text=" 新建模型 ", style="green.TButton")
|
|
|
button5.place(x=355, y=10)
|
|
|
button['button5'] = button5
|
|
|
button6 = ttk.Button(Root, text=" 图元参数设置 ", style="green.TButton")
|
|
|
button6.place(x=435, y=10)
|
|
|
button['button6'] = button6
|
|
|
button7 = ttk.Button(Root, text=" 保存模型 ", style="green.TButton")
|
|
|
button7.place(x=535, y=10)
|
|
|
button['button7'] = button7
|
|
|
button8 = ttk.Button(Root, text=" 模型正确性检查 ", style="green.TButton")
|
|
|
button8.place(x=615, y=10)
|
|
|
button['button8'] = button8
|
|
|
button9 = ttk.Button(Root, text="退出", style="green.TButton")
|
|
|
button9.place(x=725, y=10)
|
|
|
button['button9'] = button9
|
|
|
return button
|
|
|
|
|
|
'''
|
|
|
【编程16.19】编制程序：训练函数。
|
|
|
【目的及编程说明】读者通过编程16.19可掌握卷积神经网络的训练过程。其基本流程为输入数据通过前向传播预测出标签值，预测标签与真实标签进行比较得出误差，
|
|
|
反向传播误差值更新卷积层、全连接层参数，直到误差值达到阈值或迭代次数完毕。
|
|
|
基本实践内容：
|
|
|
（1）使用 AllModelObj 中的 SetParaFunc 函数初始化所有需要学习的网络参数。
|
|
|
（2）对于每个 epoch，使用AllModelConn 中的连接对象确定图元或是操作函数之间的关系，使用 AllModelObj 中的 ProcFunc
|
|
|
函数进行前向传播，并使用 AllModelObj 中的 ProcFunc 函数计算误差。再使用 AllModelObj 中的 ProcFunc 函数进行反向传播，
|
|
|
并使用 AllModelObj 中的 SetParaFunc函数更新网络参数。
|
|
|
（3）直到迭代次数停止，将生成的网络结构保存到一个文件中，以便以后使用或加载到其他神经网络中。
|
|
|
（4）若更新训练过程参数，请用户点击训练参数设置，进行更改参数，设置完毕，用户点击保存。
|
|
|
（5）获取训练参数展示区的字符串，解析字符串，对训练函数进行设置。
|
|
|
（6）点击训练按钮，进行训练。
|
|
|
'''
|
|
|
# X3所有基本图元函数
|
|
|
# 定义加载数据集的参数SetLoadData()
|
|
|
|
|
|
# 定义设置卷积参数的函数SetConvPara()
|
|
|
def setconv_para(numbers):
|
|
|
# 从Conv的ParaString得到一个包含所有卷积参数的列表
|
|
|
conv_list = Listinstance[1][5].split()
|
|
|
height, stride = conv_list[numbers - 1].split(',')
|
|
|
height = int(height)# 设置卷积核大小
|
|
|
stride = int(stride)# 设置步长
|
|
|
# 卷积核为3x3的单位矩阵(高斯分布)，通常再乘上一个小的数，比如0.01
|
|
|
kernel = np.random.randn(height, height)*0.1
|
|
|
padding = 0# 设置填充，这里假设是0
|
|
|
bias = 0.5# 设置偏置，这里假设是0.5
|
|
|
# 返回ConvPara参数,这里用一个字典来存储
|
|
|
ConvPara = {numbers: {"kernel": kernel,
|
|
|
"kernel_h": height,
|
|
|
"kernel_w": height,
|
|
|
"stride": stride,
|
|
|
"padding": padding,
|
|
|
"bias": bias}}
|
|
|
Conv0 = ModelObj("Conv", 2, "卷积", "ConvProc", "SetConvPara", ".", 340, 60).output()
|
|
|
# 若为第一个卷积层：
|
|
|
if numbers == 1:
|
|
|
# 创建全局变量的卷积图元对象实例
|
|
|
global Conv1
|
|
|
Conv1 = Conv0
|
|
|
# 令Conv1[5]等于{1: {'kernel': array(), 'kernel_h': 5, 'kernel_w': 5, 'stride': 1, 'padding': 0}
|
|
|
Conv1[5] = ConvPara
|
|
|
# 将Conv1[5][1]重新赋值到ConvPara
|
|
|
ConvPara = Conv1[5][1]
|
|
|
# 若为第二个卷积层：
|
|
|
elif numbers == 2:
|
|
|
global Conv2
|
|
|
Conv2 = Conv0
|
|
|
Conv2[5] = ConvPara
|
|
|
ConvPara = Conv2[5][2]
|
|
|
# 若为第三个卷积层：
|
|
|
elif numbers == 3:
|
|
|
global Conv3
|
|
|
Conv3 = Conv0
|
|
|
Conv3[5] = ConvPara
|
|
|
ConvPara = Conv3[5][3]
|
|
|
# 返回ConvPara,即{'kernel': array(), 'kernel_h': 5, 'kernel_w': 5, 'stride': 1, 'padding': 0}
|
|
|
return ConvPara
|
|
|
|
|
|
# 定义卷积函数ConvProc()
|
|
|
def conv_proc(image, ConvPara):
|
|
|
# 获取输入数据的大小，这里假设是单通道的图片
|
|
|
c, image_h, image_w = image.shape
|
|
|
# 获取卷积核的大小和卷积核
|
|
|
kernel_h = ConvPara["kernel_h"]
|
|
|
kernel_w = ConvPara["kernel_w"]
|
|
|
kernel = ConvPara["kernel"]
|
|
|
# 计算输出数据的大小
|
|
|
out_h = (image_h - kernel_h) // ConvPara["stride"] + 1
|
|
|
out_w = (image_w - kernel_w) // ConvPara["stride"] + 1
|
|
|
# 初始化输出数据为零矩阵
|
|
|
output = np.zeros((c, out_h, out_w))
|
|
|
# 对于每一个输出位置，进行卷积操作
|
|
|
# 遍历每个通道
|
|
|
for k in range(c):
|
|
|
# 遍历每个输出位置
|
|
|
for i in range(out_h):
|
|
|
for j in range(out_w):
|
|
|
# 获得步长和偏置
|
|
|
stride = ConvPara["stride"]
|
|
|
bias = ConvPara["bias"]
|
|
|
# 计算卷积操作
|
|
|
output[k, i, j] = np.sum(
|
|
|
image[k, i * stride:i * stride + kernel_h, j * stride:j * stride + kernel_w] * kernel) + bias
|
|
|
# 返回卷积计算后的数组（特征向量）
|
|
|
return output
|
|
|
|
|
|
# 定义设置池化参数的函数
|
|
|
def setpool_para(numbers):
|
|
|
# 从Pool的ParaString得到一个包含所有池化参数的列表
|
|
|
pool_list = Listinstance[2][5].split()
|
|
|
# 池大小和池类型
|
|
|
pool_mode, pool_size = pool_list[numbers-1].split(',')
|
|
|
print(pool_size)
|
|
|
pool_size = int(pool_size)
|
|
|
stride = 2 # 设置步长，这里假设是2
|
|
|
PoolPara = {numbers:{"pool_mode": pool_mode, # 返回PoolPara参数，这里用一个字典来存储
|
|
|
"pool_size": pool_size,
|
|
|
"stride": stride}}
|
|
|
Pool0 = ModelObj("Pool", 3, "最大池化", "MaxPoolProc", "SetPollPara", ".", 150, 150).output()
|
|
|
# 若为第一个池化层：
|
|
|
if numbers == 1:
|
|
|
# 创建全局变量的卷积图元对象实例
|
|
|
global Pool1
|
|
|
Pool1 = Pool0
|
|
|
Pool1[5] = PoolPara
|
|
|
PoolPara = Pool1[5][1]
|
|
|
# 若为第二个卷积层：
|
|
|
elif numbers == 2:
|
|
|
global Pool2
|
|
|
Pool2 = Pool0
|
|
|
Pool2[5] = PoolPara
|
|
|
PoolPara = Pool2[5][2]
|
|
|
# 若为第三个卷积层：
|
|
|
elif numbers == 3:
|
|
|
global Pool3
|
|
|
Pool3 = Pool0
|
|
|
Pool3[5] = PoolPara
|
|
|
PoolPara = Pool3[5][3]
|
|
|
|
|
|
# 返回PoolPara参数
|
|
|
return PoolPara
|
|
|
|
|
|
# 定义池化函数
|
|
|
def pool_proc(image, PoolPara):
|
|
|
# 输入：输入特征图image，PoolPara参数（字典）
|
|
|
# 输出：池化后特征图（数组）
|
|
|
# 从PoolPara参数中获取池化类型，池化窗口大小和步长
|
|
|
pool_mode = PoolPara["pool_mode"]
|
|
|
pool_size = PoolPara["pool_size"]
|
|
|
stride = PoolPara["stride"]
|
|
|
# 计算输出特征图out大小：
|
|
|
c, h, w = image.shape # 获取输入特征图的高度和宽度
|
|
|
out_h = int((h - pool_size) / stride) + 1 # 计算输出特征图的高度
|
|
|
out_w = int((w - pool_size) / stride) + 1 # 计算输出特征图的宽度
|
|
|
out = np.zeros((c, out_h, out_w)) # 初始化输出特征图为全零数组
|
|
|
# 对于输出的每一个位置上计算：
|
|
|
for k in range(c):
|
|
|
for i in range(out_h):
|
|
|
for j in range(out_w):
|
|
|
# 计算输出特征图中每个位置对应的输入特征图中的窗口区域
|
|
|
window = image[k, i * stride:i * stride + pool_size, j * stride:j * stride + pool_size]
|
|
|
# 根据池化类型，取出中间最大值或平均值或最小值，
|
|
|
if pool_mode == "max": # 最大池化
|
|
|
out[k][i][j] = np.max(window)
|
|
|
elif pool_mode == "avg": # 平均池化
|
|
|
out[k][i][j] = np.mean(window)
|
|
|
elif pool_mode == "min": # 最小池化
|
|
|
out[k][i][j] = np.min(window)
|
|
|
else: # 无效的池化类型
|
|
|
raise ValueError("Invalid pooling mode")
|
|
|
# 返回特征图。
|
|
|
return out
|
|
|
|
|
|
# 定义一个函数来设置全连接层的相关参数，这里可以根据实际情况修改或随机生成
|
|
|
def setfullconn_para(image, numbers):
|
|
|
# 获取池化后的图片数组的长度和宽度
|
|
|
data = image
|
|
|
dim = len(data.shape)
|
|
|
if dim == 2 :
|
|
|
height, width = data.shape
|
|
|
elif dim == 3:
|
|
|
c, height, width = data.shape
|
|
|
# 从FullConn的ParaString得到一个包含所有全连接参数的列表
|
|
|
fullconn_list = Listinstance[3][5].split()
|
|
|
# 设置权重矩阵及其输出维度和偏置向量
|
|
|
num_outputs = fullconn_list[numbers - 1]
|
|
|
num_outputs = int(num_outputs)
|
|
|
weights = np.random.randn(num_outputs, height * width)
|
|
|
bias = np.random.randn(1, num_outputs)
|
|
|
# 返回FullConnPara参数，这里用一个字典来存储
|
|
|
FullConnPara = {numbers: {"weights": weights,
|
|
|
"bias": bias,
|
|
|
"num_outputs": num_outputs}}
|
|
|
FullConn0 = ModelObj("FullConn", 4, "全连接", "FullConnProc", "SetFullConnPara", ".", 340, 150).output()
|
|
|
# 第一个卷积层：
|
|
|
if numbers == 1:
|
|
|
# 创建全局变量的全连接图元实例
|
|
|
global Fullconn1
|
|
|
Fullconn1 = FullConn0
|
|
|
# 令Fullconn1[5]等于{1: {'weight': array(), 'bias': array(), 'num_outputs': 7}
|
|
|
Fullconn1[5] = FullConnPara
|
|
|
# 将Fullconn1[5][1]即{'weight': array(), 'bias': array(), 'num_outputs': 7}重新赋值到FullConnPara
|
|
|
FullConnPara = Fullconn1[5][1]
|
|
|
# 第二个卷积层：
|
|
|
elif numbers == 2:
|
|
|
global Fullconn2
|
|
|
Fullconn2 = FullConn0
|
|
|
Fullconn2[5] = FullConnPara
|
|
|
FullConnPara = Fullconn2[5][2]
|
|
|
# 第三个卷积层：
|
|
|
elif numbers == 3:
|
|
|
global Fullconn3
|
|
|
Fullconn3 = FullConn0
|
|
|
Fullconn3[5] = FullConnPara
|
|
|
FullConnPara = Fullconn3[5][3]
|
|
|
# 返回FullConnPara参数
|
|
|
return FullConnPara
|
|
|
|
|
|
# 定义一个函数来完成全连接操作
|
|
|
def fullconn_proc(inputdata, FullConnPara):
|
|
|
# 从FullConnPara参数中获取权重矩阵和偏置向量
|
|
|
weights = FullConnPara["weights"]
|
|
|
bias = FullConnPara["bias"]
|
|
|
# 对输入进行展平处理，变换为单通道的一维数组格式
|
|
|
dim = len(inputdata.shape)
|
|
|
if dim == 2:
|
|
|
inputdata = inputdata.reshape(1, inputdata.shape[0] * inputdata.shape[1])
|
|
|
elif dim == 3:
|
|
|
inputdata = inputdata.reshape(1, inputdata.shape[1] * inputdata.shape[2])
|
|
|
# 计算全连接层的线性变换：inputdata与权重矩阵w进行乘法，再加上偏置向量b
|
|
|
output = np.dot(inputdata, weights.T) + bias
|
|
|
# 返回全连接计算后的数组
|
|
|
return output
|
|
|
|
|
|
# 定义设置非线性参数的函数
|
|
|
def setnonl_para():
|
|
|
# 可以选择"Sigmoid", "ReLU" 或 "Tanh"
|
|
|
# 从Nonline的ParaString得到一个包含所有非线性参数的列表
|
|
|
nonlinearmode = Listinstance[4][5]
|
|
|
# 返回NonLPara参数，这里用一个字典来存储
|
|
|
NonLPara = {"nonlinearmode": nonlinearmode}
|
|
|
# 返回NonLPara参数
|
|
|
return NonLPara
|
|
|
|
|
|
# 定义非线性函数
|
|
|
def nonlinear_proc(inputdata, NonLPara):
|
|
|
# 从NonLPara参数中获取非线性函数类型
|
|
|
nonlinearmode = NonLPara["nonlinearmode"]
|
|
|
# 判断nonlinearmode，进行相应的计算
|
|
|
if nonlinearmode == "Sigmoid":
|
|
|
# Sigmoid函数，将任何实数的输入映射到0和1之间的输出
|
|
|
output = 1 / (1 + np.exp(-inputdata))
|
|
|
# 求出Sigmoid函数的导数，用于全连接层权重矩阵和偏执向量的调整
|
|
|
output_derivative = (1 / (1 + np.exp(-inputdata))) * (1 - (1 / (1 + np.exp(-inputdata))))
|
|
|
elif nonlinearmode == "ReLU":
|
|
|
# ReLU函数，将负数输入置为0，而正数输入保持不变
|
|
|
output = np.maximum(inputdata, 0)
|
|
|
# 求出ReLU函数的导数，用于全连接层权重矩阵和偏执向量的调整
|
|
|
output_derivative = np.where(inputdata > 0, 1, 0)
|
|
|
elif nonlinearmode == "Tanh":
|
|
|
# Tanh函数，将任何实数的输入映射到-1和1之间的输出
|
|
|
output = np.tanh(inputdata)
|
|
|
# 求出Tanh函数的导数，用于全连接层权重矩阵和偏执向量的调整
|
|
|
output_derivative = 1 - np.tanh(inputdata) ** 2
|
|
|
else:
|
|
|
# 非法的非线性类型，抛出异常
|
|
|
raise ValueError("Invalid nonlinear mode")
|
|
|
# 返回计算后的值
|
|
|
return output,output_derivative
|
|
|
|
|
|
# 定义设置分类函数参数的函数
|
|
|
def setclassify_para():
|
|
|
# 设定阈值,可以根据你的数据和任务来调整阈值
|
|
|
threshold = float(Listinstance[5][5])
|
|
|
# 返回ClassifyPara参数，这里用一个字典来存储
|
|
|
ClassifyPara = {"threshold": threshold}
|
|
|
# 返回ClassifyPara参数
|
|
|
return ClassifyPara
|
|
|
|
|
|
# 定义分类函数
|
|
|
def classifier_proc(inputdata, ClassifyPara):
|
|
|
# 找到概率超过阈值的标签分类，就是分类结果
|
|
|
# 假设输入数据是一个一维数组，表示每个类别的概率
|
|
|
# 假设输出数据是一个整数，表示预测的类别编号
|
|
|
# 如果没有任何类别的概率超过阈值，就返回-1表示无法分类
|
|
|
# 定义softmax函数
|
|
|
def softmax(x):
|
|
|
# 减去最大值，防止数值溢出
|
|
|
x -= np.max(x)
|
|
|
# 计算指数和归一化
|
|
|
return np.exp(x) / np.sum(np.exp(x))
|
|
|
# 从ClassifyPara参数中获取阈值
|
|
|
threshold = ClassifyPara["threshold"]
|
|
|
# 调用softmax函数，得到概率分布向量
|
|
|
prob = softmax(inputdata)
|
|
|
# 如果概率高于阈值，就将该类别加入输出结果
|
|
|
prob1 = prob[prob >= threshold]
|
|
|
# 使用where()函数来返回等于概率最大值的元素的索引
|
|
|
index = np.where(prob == max(prob1))
|
|
|
# 使用item()方法来将索引转换为标准Python标量
|
|
|
output = index[1].item(0) + 1
|
|
|
# 返回分类标签
|
|
|
return output
|
|
|
|
|
|
# 定义设置误差参数的函数
|
|
|
def seterror_para():
|
|
|
# 确定参数信息: 标签类别，损失函数类型
|
|
|
# 从FullConn的ParaString得到一个包含所有全连接参数的列表
|
|
|
fullconn_list = Listinstance[3][5].split()
|
|
|
# 标签类别为最后一个全连接层的输出维度
|
|
|
num_outputs = fullconn_list[-1]
|
|
|
num_outputs = int(num_outputs)
|
|
|
label_list = list(range(1, num_outputs + 1))
|
|
|
# 假设损失函数类型为交叉熵（Cross Entropy Error，CEE）
|
|
|
# 从Error的ParaString得到一个包含所有全连接参数的列表
|
|
|
error_list = Listinstance[6][5].split()
|
|
|
# 设置权重矩阵及其输出维度和偏置向量
|
|
|
loss_type = error_list[-1]
|
|
|
# 返回ErrorProc参数，这里用一个元组来存储
|
|
|
ErrorPara = (label_list, loss_type)
|
|
|
# 返回ErrorPara参数
|
|
|
return ErrorPara
|
|
|
|
|
|
# 定义计算误差的函数
|
|
|
def error_proc(input, right_label, ErrorPara):
|
|
|
# 将真实标签类别label转换为one-hot编码形式
|
|
|
# 读取标签列表和损失函数类型
|
|
|
label_list, loss_type = ErrorPara
|
|
|
# 创建一个单位矩阵，大小为标签类别的个数
|
|
|
one_hot_matrix = np.eye(len(label_list))
|
|
|
# 找到标签在标签列表中的索引位置
|
|
|
index = [label_list.index(l) for l in right_label]
|
|
|
index = [x-1 for x in right_label]
|
|
|
# 从one-hot矩阵中取出对应的向量
|
|
|
label_one_hot = np.take(one_hot_matrix, index, axis=0)
|
|
|
# 确定损失函数类别，实现不同的损失函数，计算输入值与label之间的误差
|
|
|
if loss_type == "CEE":
|
|
|
# 使用交叉熵损失函数，公式为：-sum(label_one_hot * log(input)) / n
|
|
|
loss = -np.sum(label_one_hot * np.log(input)) / len(input)
|
|
|
elif loss_type == "MSE":
|
|
|
# 使用均方误差损失函数，公式为：sum((input - label_one_hot) ** 2) / n
|
|
|
loss = np.sum((input - label_one_hot) ** 2) / len(input)
|
|
|
elif loss_type == "MAE":
|
|
|
# 使用平均绝对误差损失函数，公式为：sum(abs(input - label_one_hot)) / n
|
|
|
loss = np.sum(np.abs(input - label_one_hot)) / len(input)
|
|
|
else:
|
|
|
# 如果损失函数类型不在以上三种中，抛出异常
|
|
|
raise ValueError("Invalid loss type")
|
|
|
# 返回误差值loss
|
|
|
return loss
|
|
|
|
|
|
# 定义一个卷积核调整函数,输入为卷积层的输入数据数组、卷积核、偏置、误差值，输出为更新后的卷积核、偏置
|
|
|
def update_conv_layer(input, kernel, bias, loss):
|
|
|
kernel_grad_list = []
|
|
|
bias_grad = 0 # 初始化偏置项梯度为零
|
|
|
for c in input:
|
|
|
# 计算卷积核和偏置项的梯度
|
|
|
kernel_grad = np.zeros_like(kernel) # 初始化卷积核梯度为零矩阵
|
|
|
for i in range(loss.shape[0]): # 遍历误差值矩阵的行
|
|
|
for j in range(loss.shape[1]): # 遍历误差值矩阵的列
|
|
|
# 将输入数据数组中对应的子矩阵旋转180度，与误差值相乘，累加到卷积核梯度上
|
|
|
kernel_grad += np.rot90(c[i:i + kernel_grad.shape[0], j:j + kernel_grad.shape[0]], 2) * loss[i, j]
|
|
|
# 将误差值累加到偏置项梯度上
|
|
|
bias_grad += loss[i, j]
|
|
|
kernel_grad_list.append(kernel_grad)
|
|
|
# 使用stack函数沿着第0个轴把一百个a数组堆叠起来
|
|
|
result = np.stack(kernel_grad_list, axis=0)
|
|
|
kernel_grad = np.sum(result, axis=0)/len(input) # 沿着第0个维度求和
|
|
|
# 设置学习率为0.01
|
|
|
learning_rate = 0.01
|
|
|
# 更新卷积核和偏置项参数
|
|
|
kernel = kernel - learning_rate * kernel_grad # 卷积核参数减去学习率乘以卷积核梯度
|
|
|
bias = bias - learning_rate * bias_grad # 偏置项参数减去学习率乘以偏置项梯度
|
|
|
# 返回更新后的卷积核、偏置
|
|
|
return kernel, bias
|
|
|
|
|
|
# 定义一个全连接层的权重矩阵和偏置向量的调整函数，可以选择不同的激活函数
|
|
|
def update_parameters(input_data, weight_matrix, bias_vector, loss, output_derivative):
|
|
|
# 根据激活函数的参数选择相应的函数和导数
|
|
|
# 计算权重矩阵和偏置向量的梯度，使用链式法则
|
|
|
weight_matrix_grad = np.dot(input_data.T, loss * output_derivative)
|
|
|
bias_vector_grad = np.sum(loss * output_derivative, axis=0)
|
|
|
learning_rate = 0.01
|
|
|
# 更新权重矩阵和偏置向量
|
|
|
weight_matrix = weight_matrix - learning_rate * weight_matrix_grad
|
|
|
bias_vector = bias_vector - learning_rate * bias_vector_grad
|
|
|
# 返回更新后的权重矩阵和偏置向量
|
|
|
return weight_matrix, bias_vector
|
|
|
|
|
|
# X4交互式构建卷积神经网络模型
|
|
|
# 定义图元拖拽开始的函数
|
|
|
def on_drag_start(event):
|
|
|
global Dragged_item # 记录被拖拽的图元id
|
|
|
global Original_x # 记录图元原来的x坐标
|
|
|
global Original_y # 记录图元原来的y坐标
|
|
|
global Offset_x # 记录鼠标相对于图元的x偏移量
|
|
|
global Offset_y # 记录鼠标相对于图元的y偏移量
|
|
|
# 获取当前图元的id
|
|
|
# 这个物体的id是由tkinter自动分配的。当在画布上创建一个物体时，它会返回一个唯一的整数id，可以用它来引用这个物体
|
|
|
Dragged_item = event.widget.find_closest(event.x, event.y)
|
|
|
|
|
|
Original_x = event.widget.coords(Dragged_item)[0] # 获取当前图元的x坐标
|
|
|
Original_y = event.widget.coords(Dragged_item)[1] # 获取当前图元的y坐标
|
|
|
Offset_x = Original_x - event.x # 计算鼠标相对于图元的x偏移量
|
|
|
Offset_y = Original_y - event.y # 计算鼠标相对于图元的y偏移量
|
|
|
|
|
|
# 定义图元拖拽移动的函数
|
|
|
def on_drag_motion(event):
|
|
|
x = event.x + Offset_x # 计算图元新的x坐标
|
|
|
y = event.y + Offset_y # 计算图元新的y坐标
|
|
|
event.widget.coords(Dragged_item, x, y) # 更新图元的位置
|
|
|
|
|
|
def entity_loading_dataset(event):
|
|
|
global Viewcanvas
|
|
|
x = event.x + Offset_x
|
|
|
y = event.y + Offset_y
|
|
|
|
|
|
Items3.append(0) # 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
new_item1 = Viewcanvas.create_image(x, y, image=List_image[0]) # 复制一个图片，表示数据集1
|
|
|
Viewcanvas.create_text(x, y + 45, text='数据集')# 复制图元对象的标签
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y)# 恢复图元的原位置
|
|
|
Items1.append((new_item1, x, y))# 将新图元的id和坐标添加到列表中
|
|
|
global Yt
|
|
|
Items_y = Items1[0] # 将新图元的y坐标取出，方便后续图元水平排列
|
|
|
Yt = Items_y[2]
|
|
|
# 创建一个tkinter根窗口，并隐藏它
|
|
|
root1 = tk.Tk()
|
|
|
root1.withdraw()
|
|
|
|
|
|
DataPara = setload_data() # 调用X3中setload_data()函数，获取加载数据集的参数
|
|
|
global Train_images
|
|
|
global Test_images
|
|
|
Train_images, Test_images = load_data(DataPara) # 调用X3中load_data()函数，根据参数加载数据集
|
|
|
# 打印一些信息，检查是否正确加载
|
|
|
print("训练集图片的形状：", Train_images.shape)
|
|
|
print("测试集图片的形状：", Test_images.shape)
|
|
|
|
|
|
# 创建弹出窗口
|
|
|
def creat_window(title):
|
|
|
top = tk.Toplevel(Root)
|
|
|
top.geometry("300x350")
|
|
|
top.title(title)
|
|
|
return top
|
|
|
# 输入框
|
|
|
def create_input_box(top, text,value):
|
|
|
box_label = tk.Label(top, text=text)
|
|
|
box_label.pack(padx=10, pady=10)
|
|
|
box_size = tk.IntVar(top, value=value) # 创建一个IntVar对象，并设置默认值为3
|
|
|
box_size_entry = tk.Entry(top, textvariable=box_size) # 关联IntVar对象
|
|
|
box_size_entry.pack(padx=20, pady=20)
|
|
|
return box_size_entry
|
|
|
# 下拉框
|
|
|
def create_dropdown_box(top, text, listvalues):
|
|
|
# 创建一个下拉框，用于选择
|
|
|
box_mode_label = tk.Label(top, text=text)
|
|
|
box_mode_label.pack(padx=10, pady=10)
|
|
|
box_mode_combobox = ttk.Combobox(top)
|
|
|
box_mode_combobox["values"] = listvalues
|
|
|
box_mode_combobox.pack(padx=20, pady=15)
|
|
|
return box_mode_combobox
|
|
|
|
|
|
def convolution(event):
|
|
|
global Items3
|
|
|
global Viewcanvas
|
|
|
x = event.x + Offset_x
|
|
|
Items3.append(1) # 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
new_item1 = Viewcanvas.create_image(x, Yt, image=List_image[1]) # 复制一个图片，表示卷积层
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y) # 恢复图元的原位置
|
|
|
Items1.append((new_item1, x, Yt)) # 将新图元的id和坐标添加到列表中
|
|
|
top = creat_window('卷积参数配置') # 创建弹出窗口
|
|
|
kernel_size_entry = create_input_box(top,"卷积核大小：",3) # 创建一个输入框，获取卷积核大小
|
|
|
stride_entry = create_input_box(top,"卷积步长：",1) # 创建一个输入框，获取卷积步长
|
|
|
def get_input(): # 创建
|
|
|
# 获取输入框的内容
|
|
|
global Listinstance
|
|
|
result1 = int(kernel_size_entry.get())
|
|
|
result2 = int(stride_entry.get())
|
|
|
Viewcanvas.create_text(x, Yt + 40, text=str(result1) + "*" + str(result1) + "卷积") # 创建图元对象的标签
|
|
|
if Listinstance[1][5] == ".":
|
|
|
Listinstance[1][5] = str(result1) + "," + str(result2)
|
|
|
else:
|
|
|
Listinstance[1][5] = Listinstance[1][5] + " " + str(result1) + "," + str(result2)
|
|
|
top.destroy()# 关闭窗口
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def pooling(event):
|
|
|
global Items3
|
|
|
global Viewcanvas
|
|
|
x = event.x + Offset_x
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(2)
|
|
|
# 复制一个图片，表示池化层
|
|
|
new_item1 = Viewcanvas.create_image(x, Yt, image=List_image[2])
|
|
|
# 恢复图元的原位置
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y)
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, Yt))
|
|
|
# 创建弹出窗口
|
|
|
top=creat_window("池化参数配置")
|
|
|
pool_type_combobox=create_dropdown_box(top, "池化池类型：", ["max", "avg", "min"])# 创建一个下拉框，用于选择池化类型
|
|
|
pool_size_entry = create_input_box(top, "池化池大小：", 2)# 创建一个输入框，用于输入池大小
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 从下拉框中获取池化类型
|
|
|
pool_type = pool_type_combobox.get()
|
|
|
# 从输入框中获取池大小
|
|
|
pool_size = int(pool_size_entry.get())
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, Yt + 40, text=str(pool_size) + "*" + str(pool_size) + str(pool_type) + "池化")
|
|
|
if Listinstance[2][5] == ".":
|
|
|
Listinstance[2][5] = str(pool_type) + "," + str(pool_size)
|
|
|
else:
|
|
|
Listinstance[2][5] = Listinstance[2][5] + " " + str(pool_type) + "," + str(pool_size)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def fully_connected(event):
|
|
|
global Items3
|
|
|
global Viewcanvas
|
|
|
x = event.x + Offset_x
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(3)
|
|
|
# 复制一个图片，表示全连接层
|
|
|
new_item1 = Viewcanvas.create_image(x, Yt, image=List_image[3])
|
|
|
# 恢复图元的原位置
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y)
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, Yt))
|
|
|
top = tk.Toplevel(Root) # 创建弹出窗口
|
|
|
top.geometry("300x250")
|
|
|
top.title("全连接参数配置")
|
|
|
num_outputs_entry = create_input_box(top, "全连接输出维度：", 10)
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
global Listinstance
|
|
|
# 从下拉框中获取输出维度
|
|
|
num = int(num_outputs_entry.get())
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, Yt + 40, text=str(num) + "--全连接")
|
|
|
if Listinstance[3][5] == ".":
|
|
|
Listinstance[3][5] = str(num)
|
|
|
else:
|
|
|
Listinstance[3][5] = Listinstance[3][5] + " " + str(num)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack(padx=20, pady=50)
|
|
|
|
|
|
def nonlinear(event):
|
|
|
global Items3
|
|
|
global Viewcanvas
|
|
|
x = event.x + Offset_x
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(4)
|
|
|
# 复制一个图片，表示非线性函数图元
|
|
|
new_item1 = Viewcanvas.create_image(x, Yt, image=List_image[4])
|
|
|
# 恢复图元的原位置
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y)
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, Yt))
|
|
|
top = creat_window('非线性参数配置') # 创建弹出窗口
|
|
|
# 创建一个下拉框，用于选择非线性类型
|
|
|
nonlinear_mode_combobox = create_dropdown_box(top, "非线性类型", ["Sigmoid", "ReLU", "Tanh"])# 创建一个下拉框，用于选择池化类型
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
global Listinstance
|
|
|
# 从下拉框中获取池化类型
|
|
|
nonlinear_mode = nonlinear_mode_combobox.get()
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, Yt + 40, text=str(nonlinear_mode) + "处理")
|
|
|
if Listinstance[4][5] == ".":
|
|
|
Listinstance[4][5] = str(nonlinear_mode)
|
|
|
else:
|
|
|
Listinstance[4][5] = Listinstance[4][5] + " " + str(nonlinear_mode)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def class_ification(event):
|
|
|
global Listinstance
|
|
|
global Viewcanvas
|
|
|
global Items3
|
|
|
x = event.x + Offset_x
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(5)
|
|
|
# 复制一个图片，表示分类器
|
|
|
new_item1 = Viewcanvas.create_image(x, Yt, image=List_image[5])
|
|
|
# 恢复图元的原位置
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y)
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, Yt))
|
|
|
top = tk.Toplevel(Root) # 创建弹出窗口
|
|
|
top.geometry("300x250")
|
|
|
top.title("分类参数配置")
|
|
|
# 创建一个输入框，用于输入阈值
|
|
|
threshold_label = tk.Label(top, text="阈值：")
|
|
|
threshold_label.pack(padx=10, pady=10)
|
|
|
threshold = tk.DoubleVar(top, value=0.001) # 创建一个DoubleVar对象，并设置默认值为0.001
|
|
|
threshold_entry = tk.Entry(top, textvariable=threshold) # 关联DoubleVar对象
|
|
|
threshold_entry.pack(padx=20, pady=20)
|
|
|
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 从输入框中获取阈值
|
|
|
threshold = float(threshold_entry.get())
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, Yt + 40, text="输出分类结果")
|
|
|
if Listinstance[5][5] == ".":
|
|
|
Listinstance[5][5] = str(threshold)
|
|
|
else:
|
|
|
Listinstance[5][5] = Listinstance[5][5] + " " + str(threshold)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def error_calculation(event):
|
|
|
global Items3
|
|
|
global Viewcanvas
|
|
|
x = event.x + Offset_x
|
|
|
y = event.y + Offset_y
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(6)
|
|
|
# 复制一个图片，表示误差计算
|
|
|
new_item1 = Viewcanvas.create_image(x, y, image=List_image[6])
|
|
|
# 恢复图元的原位置
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y)
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, y))
|
|
|
global x_loss
|
|
|
global y_loss
|
|
|
x_loss = x
|
|
|
y_loss = y
|
|
|
# 创建弹出窗口
|
|
|
top = creat_window('误差参数配置')
|
|
|
# 创建一个下拉框，用于选择误差类型
|
|
|
loss_type_combobox=create_dropdown_box(top, '', ["CEE", "MSE", "MAE"])
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 从下拉框中获取池化类型
|
|
|
loss_type = loss_type_combobox.get()
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, y_loss + 40,
|
|
|
text=str(loss_type) + "误差计算")
|
|
|
if Listinstance[6][5] == ".":
|
|
|
Listinstance[6][5] = str(loss_type)
|
|
|
else:
|
|
|
Listinstance[6][5] = Listinstance[6][5] + " " + str(loss_type)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def adjust_one(event):
|
|
|
global Viewcanvas
|
|
|
global Items1
|
|
|
global Items3
|
|
|
x = event.x + Offset_x
|
|
|
y = event.y + Offset_y
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(7)
|
|
|
# 复制一个图片，表示调整操作
|
|
|
new_item1 = Viewcanvas.create_image(x, y_loss - 20, image=List_image[7])
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, y_loss + 20, text='调整1')
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y) # 恢复图元的原位置
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, y))
|
|
|
|
|
|
|
|
|
def adjust_two(event):
|
|
|
global Viewcanvas
|
|
|
global Items1
|
|
|
global Items3
|
|
|
x = event.x + Offset_x
|
|
|
y = event.y + Offset_y
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(8)
|
|
|
# 复制一个图片，表示调整操作
|
|
|
new_item1 = Viewcanvas.create_image(x, y_loss + 20, image=List_image[7])
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, y_loss + 60, text='调整2')
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y) # 恢复图元的原位置
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, y))
|
|
|
|
|
|
|
|
|
def adjust_three(event):
|
|
|
global Viewcanvas
|
|
|
global Items1
|
|
|
global Items3
|
|
|
x = event.x + Offset_x
|
|
|
y = event.y + Offset_y
|
|
|
# 记录被拖拽的原始图元的id，方便后续进行模型的正确性检查
|
|
|
Items3.append(9)
|
|
|
# 复制一个图片，表示调整操作
|
|
|
new_item1 = Viewcanvas.create_image(x, y, image=List_image[7])
|
|
|
# 复制对象的标签
|
|
|
Viewcanvas.create_text(x, y + 40, text='调整3')
|
|
|
event.widget.coords(Dragged_item, Original_x, Original_y) # 恢复图元的原位置
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
Items1.append((new_item1, x, y))
|
|
|
|
|
|
def connecting_line():
|
|
|
global Viewcanvas
|
|
|
global Items2
|
|
|
last_item = Items1[-1] # 获取最后一个图元的id和坐标
|
|
|
prev_item = Items1[-2] # 获取倒数第二个图元的id和坐标
|
|
|
# 获取最后一个图元的边界框坐标，形式为(x1,y1,x2,y2)，其中(x1,y1)是左上角，(x2,y2)是右下角
|
|
|
last_bbox = Viewcanvas.bbox(last_item[0])
|
|
|
# 获取倒数第二个图元的边界框坐标，形式同上
|
|
|
prev_bbox = Viewcanvas.bbox(prev_item[0])
|
|
|
# 计算线条的起点和终点，使其与图元的边界对齐，并留出一定距离以避免重叠
|
|
|
start_x = prev_bbox[2] + 5 # 起点x坐标为倒数第二个图元右边界加10像素
|
|
|
start_y = prev_bbox[3] - (prev_bbox[3] - prev_bbox[1]) / 2 # 起点y坐标为倒数第二个图元垂直中心
|
|
|
end_x = last_bbox[0] # 终点x坐标为最后一个图元左边界
|
|
|
end_y = last_bbox[3] - (last_bbox[3] - last_bbox[1]) / 2 # 终点y坐标为最后一个图元垂直中心
|
|
|
# 创建一条线，带有箭头，并设置箭头形状、大小、颜色和平滑度等参数
|
|
|
if Items3[-1] < 6:
|
|
|
new_item = Viewcanvas.create_line(start_x, start_y, end_x, end_y, arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=True)
|
|
|
if Items3[-1] == 1:
|
|
|
x = last_bbox[2] - (last_bbox[2] - last_bbox[0]) / 2
|
|
|
y = last_bbox[1]
|
|
|
Conv_xy_list.append((x, y))
|
|
|
if Items3[-1] == 3:
|
|
|
x = last_bbox[2] - (last_bbox[2] - last_bbox[0]) / 2
|
|
|
y = last_bbox[1]
|
|
|
Fullconn_xy_list.append((x, y))
|
|
|
|
|
|
elif Items3[-1] == 6:
|
|
|
# 计算折线的中间点，使其与图元的边界对齐，并留出一定距离以避免重叠
|
|
|
mid_x = prev_bbox[2] - (prev_bbox[2] - prev_bbox[0]) / 2 # 中间点x坐标为起点和终点的平均值
|
|
|
mid_y = prev_bbox[1] - 80 # 中间点y坐标为起点y坐标减20像素
|
|
|
# 创建一条折线，带有箭头，并设置箭头形状、大小、颜色和平滑度等参数
|
|
|
x1 = prev_bbox[2] - (prev_bbox[2] - prev_bbox[0]) / 2
|
|
|
y1 = prev_bbox[1]
|
|
|
x2 = last_bbox[2]
|
|
|
y2 = last_bbox[3] - (last_bbox[3] - last_bbox[1]) / 2
|
|
|
new_item = Viewcanvas.create_line(x1, y1, mid_x, mid_y, x2, y2, arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=False)
|
|
|
elif Items3[-1] == 7:
|
|
|
x1 = x_loss
|
|
|
y1 = y_loss
|
|
|
x2, y2 = Conv_xy_list[0]
|
|
|
new_item = Viewcanvas.create_line(x1, y1, last_bbox[2] - (last_bbox[2] - last_bbox[0]) / 2,
|
|
|
last_bbox[3] - (last_bbox[3] - last_bbox[1]) / 2, x2, y2, arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=False)
|
|
|
Conv_xy_list.remove(Conv_xy_list[0])
|
|
|
elif Items3[-1] == 8:
|
|
|
x1 = x_loss
|
|
|
y1 = y_loss
|
|
|
x2, y2 = Fullconn_xy_list[0]
|
|
|
new_item = Viewcanvas.create_line(x1, y1, last_bbox[2] - (last_bbox[2] - last_bbox[0]) / 2,
|
|
|
last_bbox[3] - (last_bbox[3] - last_bbox[1]) / 2, x2, y2, arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=False)
|
|
|
Fullconn_xy_list.remove(Fullconn_xy_list[0])
|
|
|
Items2.append(new_item)
|
|
|
|
|
|
def on_drag(obj_id1,event):
|
|
|
while obj_id1 == 4: # 如果拖拽的是图元加载数据集
|
|
|
entity_loading_dataset(event)
|
|
|
break
|
|
|
while obj_id1 == 6: # 卷积
|
|
|
convolution(event)
|
|
|
break
|
|
|
while obj_id1 == 8: # 池化
|
|
|
pooling(event)
|
|
|
break
|
|
|
while obj_id1 == 10: # 全连接
|
|
|
fully_connected(event)
|
|
|
break
|
|
|
while obj_id1 == 12: # 非线性
|
|
|
nonlinear(event)
|
|
|
break
|
|
|
while obj_id1 == 14: # 分类
|
|
|
class_ification(event)
|
|
|
break
|
|
|
while obj_id1 == 16: # 误差计算
|
|
|
error_calculation(event)
|
|
|
break
|
|
|
while obj_id1 == 18: # 调整1
|
|
|
adjust_one(event)
|
|
|
break
|
|
|
while obj_id1 == 20: # 调整2
|
|
|
adjust_two(event)
|
|
|
break
|
|
|
while obj_id1 == 22: # 调整3
|
|
|
adjust_three(event)
|
|
|
break
|
|
|
|
|
|
# 定义图元拖拽结束的函数
|
|
|
def on_drag_end(event):
|
|
|
obj_id1 = Dragged_item[0] # 获取被拖拽的图元的id
|
|
|
# 使用 print(obj_id1) 从而查看各个图元的id,此步省略
|
|
|
# 根据图元的类型，复制相应的图片到右侧画布
|
|
|
on_drag(obj_id1,event)
|
|
|
# 如果列表中有至少两个图元，就创建一条线，连接最后两个图元的中心点
|
|
|
while len(Items1) >= 2:
|
|
|
connecting_line()
|
|
|
break
|
|
|
def element_binding(obj_x, obj_y, image, y, text):
|
|
|
global Viewcanvas
|
|
|
# 创建图元对象
|
|
|
l1 = Viewcanvas.create_image(obj_x, obj_y, image=image)
|
|
|
# 创建图元对象的标签
|
|
|
Viewcanvas.create_text(obj_x - 40, obj_y + y, text=text, font=("黑体", 8))
|
|
|
return l1
|
|
|
|
|
|
def create_left_element(AllModelObj,List_image):
|
|
|
global Viewcanvas
|
|
|
# 遍历AllModelObj列表，在窗口左侧创建图元菜单
|
|
|
for obj in AllModelObj:
|
|
|
# 获取图元对象的类型、标签等信息
|
|
|
obj_id = obj[0]
|
|
|
obj_type = obj[1]
|
|
|
obj_label = obj[2]
|
|
|
# 并且要根据需求调整每个对象的位置
|
|
|
obj_x = obj[6] # 根据对象的id计算x坐标
|
|
|
obj_y = obj[7] # 根据对象的id计算y坐标
|
|
|
# 根据对象的类型，绘制相应的图形
|
|
|
if obj_type == 1: # 加载数据集
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[0], 3, " 加载" + "\n" + "数据集")
|
|
|
elif obj_type == 2: # 卷积
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[1], 0, "卷积")
|
|
|
elif obj_type == 3: # 池化
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[2], 0, "池化")
|
|
|
elif obj_type == 4: # 全连接
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[3], 0, "全连接" + "\n" + " 函数")
|
|
|
elif obj_type == 5: # 非线性
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[4], 0, "非线性" + "\n" + " 函数")
|
|
|
elif obj_type == 6: # 分类
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[5], 0, "类别")
|
|
|
elif obj_type == 7: # 误差计算
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[6], 0, "误差")
|
|
|
elif obj_type == 8: # 调整
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[7], 0, "调整1")
|
|
|
elif obj_type == 9: # 调整
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[7], 0, "调整2")
|
|
|
elif obj_type == 10: # 调整
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[7], 0, "调整3")
|
|
|
elif obj_type == 11: # 调整
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[8], 3, "主数据连接线")
|
|
|
elif obj_type == 12: # 调整
|
|
|
l1 = element_binding(obj_x, obj_y, List_image[9], 3, "参数连接线")
|
|
|
# 为左边菜单的每个图元绑定鼠标按下、移动和松开的事件
|
|
|
Viewcanvas.tag_bind(l1, "<Button-1>", on_drag_start)
|
|
|
Viewcanvas.tag_bind(l1, "<B1-Motion>", on_drag_motion)
|
|
|
Viewcanvas.tag_bind(l1, "<ButtonRelease-1>", on_drag_end)
|
|
|
|
|
|
def train_setting():
|
|
|
global Train_list
|
|
|
Train_list = []
|
|
|
top = creat_window("训练参数配置")# 创建弹出的参数配置窗口
|
|
|
epoch_entry = create_input_box(top,"训练轮数：", 4)# 创建一个输入框，获取训练轮数
|
|
|
rate_entry=create_input_box(top, '学习率：', 0.1)# 创建一个输入框，获取学习率
|
|
|
batch_size_entry=create_input_box(top, "批次：", 60)# 创建一个输入框，获取批次
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(epoch_entry.get())
|
|
|
result2 = float(rate_entry.get())
|
|
|
result3 = int(batch_size_entry.get())
|
|
|
Train_list.append(result1)
|
|
|
Train_list.append(result2)
|
|
|
Train_list.append(result3)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def conn_forward(counts,layer,outputs):
|
|
|
# 若为第一层卷积层且该层的图元实例Conv1还未创建
|
|
|
if counts[layer] == 1 and Conv1 is None:
|
|
|
# 调用SetConvPara()函数，获取卷积层1参数
|
|
|
ConvPara = setconv_para(counts[layer])
|
|
|
# 若图元实例Conv1已经被定义，说明需要根据反向传播调整卷积核
|
|
|
if counts[layer] == 1 and Conv1 is not None:
|
|
|
ConvPara = Conv1[5][1]
|
|
|
if counts[layer] == 2 and Conv2 is None:
|
|
|
ConvPara = setconv_para(counts[layer])
|
|
|
if counts[layer] == 2 and Conv2 is not None:
|
|
|
ConvPara = Conv2[5][2]
|
|
|
if counts[layer] == 3 and Conv3 is None:
|
|
|
ConvPara = setconv_para(counts[layer])
|
|
|
if counts[layer] == 3 and Conv3 is not None:
|
|
|
ConvPara = Conv3[5][3]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对每一张图片进行前向传播
|
|
|
for output in outputs:
|
|
|
# 获取矩阵的维度
|
|
|
dim = len(output.shape)
|
|
|
# 如果是二维矩阵,则转化为三维矩阵
|
|
|
if dim == 2:
|
|
|
image_h, image_w = output.shape
|
|
|
output = np.reshape(output, (1, image_h, image_w))
|
|
|
# 调用ConvProc()函数，根据ConvPara参数完成卷积计算
|
|
|
output = conv_proc(output, ConvPara)
|
|
|
new_outputs.append(output)
|
|
|
# 若为三维矩阵，则保持不变直接卷积处理
|
|
|
elif dim == 3:
|
|
|
output = conv_proc(output, ConvPara)
|
|
|
new_outputs.append(output)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("卷积处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
def pool_forward(counts,layer,outputs):
|
|
|
global Pool1
|
|
|
global Pool2
|
|
|
global Pool3
|
|
|
if counts[layer] == 1 and Pool1 is None:
|
|
|
# 调用设置池化层参数的函数，获取池化参数
|
|
|
PoolPara = setpool_para(counts[layer])
|
|
|
if counts[layer] == 1 and Pool1 is not None:
|
|
|
PoolPara = Pool1[5][1]
|
|
|
if counts[layer] == 2 and Pool2 is None:
|
|
|
PoolPara = setpool_para(counts[layer])
|
|
|
if counts[layer] == 2 and Pool2 is not None:
|
|
|
PoolPara = Pool2[5][2]
|
|
|
if counts[layer] == 3 and Pool3 is None:
|
|
|
PoolPara = setpool_para(counts[layer])
|
|
|
if counts[layer] == 3 and Pool3 is not None:
|
|
|
PoolPara = Pool3[5][3]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对outputs列表中的每个元素调用PoolProc函数，并将结果添加到new_outputs列表中
|
|
|
for output in outputs:
|
|
|
new_outputs.append(pool_proc(output, PoolPara))
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
if counts[layer] == 1:
|
|
|
Pool1.append(outputs)
|
|
|
if counts[layer] == 2:
|
|
|
Pool2.append(outputs)
|
|
|
if counts[layer] == 3:
|
|
|
Pool3.append(outputs)
|
|
|
print("池化处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
|
|
|
def fullconn_forward(counts,layer,outputs):
|
|
|
output = outputs[0]
|
|
|
# 若图元实例Fullconn1未被定义
|
|
|
if counts[layer] == 1 and Fullconn1 is None:
|
|
|
# 调用设置全连接层参数的函数，获取全连接参数
|
|
|
FullConnPara = setfullconn_para(output, counts[layer])
|
|
|
# 若图元实例Fullconn1已经被定义，说明需要根据反向传播调整权重矩阵和偏置向量
|
|
|
if counts[layer] == 1 and Fullconn1 is not None:
|
|
|
FullConnPara = Fullconn1[5][1]
|
|
|
if counts[layer] == 2 and Fullconn2 is None:
|
|
|
FullConnPara = setfullconn_para(output, counts[layer])
|
|
|
if counts[layer] == 2 and Fullconn2 is not None:
|
|
|
FullConnPara = Fullconn2[5][2]
|
|
|
if counts[layer] == 3 and Fullconn3 is None:
|
|
|
FullConnPara = setfullconn_para(output, counts[layer])
|
|
|
if counts[layer] == 3 and Fullconn3 is not None:
|
|
|
FullConnPara = Fullconn3[5][3]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对outputs列表中的每个元素调用FullConnProc函数，并将结果添加到new_outputs列表中
|
|
|
for output in outputs:
|
|
|
new_outputs.append(fullconn_proc(output, FullConnPara))
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
|
|
|
print("全连接处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
|
|
|
def nonlinear_forward(outputs):
|
|
|
# 调用设置非线性参数的函数，获取非线性参数
|
|
|
NonLPara = setnonl_para()
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对outputs列表中的每个元素调用NonlinearProc函数，并将结果添加到new_outputs列表中
|
|
|
for output in outputs:
|
|
|
output, output_derivative = nonlinear_proc(output, NonLPara)
|
|
|
new_outputs.append(output)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("非线性处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
|
|
|
return outputs
|
|
|
|
|
|
def classifier_forward(outputs):
|
|
|
# 设置分类函数参数
|
|
|
ClassifyPara = setclassify_para()
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
global Prob_images
|
|
|
Prob_images = []
|
|
|
# 定义softmax函数
|
|
|
def softmax(x):
|
|
|
# 减去最大值，防止数值溢出
|
|
|
x -= np.max(x)
|
|
|
# 计算指数和归一化
|
|
|
return np.exp(x) / np.sum(np.exp(x))
|
|
|
|
|
|
# 对outputs列表中的每个元素调用ClassifierProc函数，并将结果添加到new_outputs列表中
|
|
|
for output in outputs:
|
|
|
new_outputs.append(classifier_proc(output, ClassifyPara))
|
|
|
# 调用softmax函数，得到概率分布向量
|
|
|
prob = softmax(output)
|
|
|
# 将概率向量结果存储到列表
|
|
|
Prob_images.append(prob)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("输出示例概率向量：")
|
|
|
print(Prob_images[0:3])
|
|
|
print("")
|
|
|
|
|
|
return outputs
|
|
|
# 前向传播
|
|
|
def forward_propagation(Train_images):
|
|
|
images = Train_images# 获取训练集
|
|
|
outputs = images# 存储每一层的输出结果的列表
|
|
|
Counts = {}# 根据前向传播顺序列表，依次进行卷积层、池化层、全连接层、非线性层和分类层的操作
|
|
|
for layer in Items3[1:]:
|
|
|
if layer not in Counts:# 如果layer是第一次出现，就把它加入字典，并设置计数器为1
|
|
|
Counts[layer] = 1
|
|
|
else:# 如果layer已经出现过，就把它的计数器加一
|
|
|
Counts[layer] += 1
|
|
|
if layer == 1:# 如果是卷积层，就调用ConvProc函数，根据卷积核和步长进行卷积计算，并更新输出结果
|
|
|
outputs = conn_forward(Counts,layer,outputs)
|
|
|
elif layer == 2:# 如果是池化层，就调用PoolProc函数，进行池化计算，并更新输出结果
|
|
|
outputs = pool_forward(Counts,layer,outputs)
|
|
|
elif layer == 3:# 如果是全连接层，就调用FullConnProc函数，根据权重矩阵和偏置向量进行全连接计算，并更新输出结果
|
|
|
outputs= fullconn_forward(Counts,layer,outputs)
|
|
|
elif layer == 4: # 如果是非线性层，就调用NonlinearProc函数，根据激活函数进行非线性变换，并更新输出结果
|
|
|
outputs = nonlinear_forward(outputs)
|
|
|
elif layer == 5:# 如果是分类层，就调用ClassifierProc函数，根据权重矩阵和偏置向量进行分类计算，并更新输出结果
|
|
|
outputs=classifier_forward(outputs)
|
|
|
outputs = np.array(outputs)# 将输出结果列表转换为数组形式，方便后续处理
|
|
|
return outputs# 返回输出结果数组
|
|
|
|
|
|
def conv_one(loss,images):
|
|
|
global Conv1
|
|
|
kernel = Conv1[5][1]["kernel"]
|
|
|
bias = 0.5
|
|
|
loss = np.array([[loss]])
|
|
|
new_kernel, new_bias = update_conv_layer(images, kernel, bias, loss)
|
|
|
Conv1[5][1]["kernel"] = new_kernel
|
|
|
Conv1[5][1]["bias"] = new_bias
|
|
|
|
|
|
def conv_two(loss, images):
|
|
|
global Conv1
|
|
|
global Conv2
|
|
|
kernel1 = Conv1[5][1]["kernel"]
|
|
|
bias1 = 0.5
|
|
|
loss = np.array([[loss]])
|
|
|
new_kernel1, new_bias1 = update_conv_layer(images, kernel1, bias1, loss)
|
|
|
Conv1[5][1]["kernel"] = new_kernel1
|
|
|
Conv1[5][1]["bias"] = new_bias1
|
|
|
|
|
|
kernel2 = Conv2[5][2]["kernel"]
|
|
|
bias2 = 0.5
|
|
|
loss = np.array([[loss]])
|
|
|
new_kernel2, new_bias2 = update_conv_layer(Pool1[-1], kernel2, bias2, loss)
|
|
|
Conv2[5][2]["kernel"] = new_kernel2
|
|
|
Conv2[5][2]["bias"] = new_bias2
|
|
|
|
|
|
def conv_three(loss, images):
|
|
|
global Conv1
|
|
|
global Conv2
|
|
|
global Conv3
|
|
|
kernel1 = Conv1[5][1]["kernel"]
|
|
|
bias1 = 0.5
|
|
|
loss = np.array([[loss]])
|
|
|
new_kernel1, new_bias1 = update_conv_layer(images, kernel1, bias1, loss)
|
|
|
Conv1[5][1]["kernel"] = new_kernel1
|
|
|
Conv1[5][1]["bias"] = new_bias1
|
|
|
kernel2 = Conv2[5][2]["kernel"]
|
|
|
bias2 = 0.5
|
|
|
loss = np.array([[loss]])
|
|
|
new_kernel2, new_bias2 = update_conv_layer(Pool1[-1], kernel2, bias2, loss)
|
|
|
Conv2[5][2]["kernel"] = new_kernel2
|
|
|
Conv2[5][2]["bias"] = new_bias2
|
|
|
kernel3 = Conv3[5][3]["kernel"]
|
|
|
bias3 = 0.5
|
|
|
loss = np.array([[loss]])
|
|
|
new_kernel3, new_bias3 = update_conv_layer(Pool2[-1], kernel3, bias3, loss)
|
|
|
Conv3[5][3]["kernel"] = new_kernel3
|
|
|
Conv3[5][3]["bias"] = new_bias3
|
|
|
|
|
|
def determine(Train_list,Items3):
|
|
|
if len(Train_list) == 0:
|
|
|
messagebox.showerror("错误", "请设置训练参数！")
|
|
|
return 0
|
|
|
if len(Items3) == 0:
|
|
|
messagebox.showerror("错误", "请添加图元！")
|
|
|
return 0
|
|
|
return 1
|
|
|
def label_array(i):
|
|
|
# 读取标签数据
|
|
|
df = pd.read_csv('data/emotion.csv', header=None, skiprows=range(0, i * batch), nrows=(i + 1) * batch - i * batch)
|
|
|
# 将标签数据转化成数组
|
|
|
right_label = df.iloc[:, 0].tolist()
|
|
|
right_label = list(map(int, right_label))
|
|
|
right_label = [x + 1 for x in right_label]
|
|
|
return right_label
|
|
|
|
|
|
def train():# 训练
|
|
|
if determine(Train_list, Items3) == 0:
|
|
|
return
|
|
|
epoch,rate,batch_size = Train_list
|
|
|
first_epoch = 1
|
|
|
while first_epoch <= epoch:
|
|
|
first_epoch = first_epoch + 1
|
|
|
for i in range(len(Train_images) // batch_size):
|
|
|
images = Train_images[i * batch_size:(i + 1) * batch_size]
|
|
|
forward_propagation(images)
|
|
|
global Prob_images
|
|
|
Prob_images = np.squeeze(Prob_images) # 获取分类结果的概率向量数组
|
|
|
global batch
|
|
|
batch = len(Prob_images)
|
|
|
right_label = label_array(i) # 读取标签数据,将标签数据转化成数组
|
|
|
ErrorPara = seterror_para() # 设置误差参数
|
|
|
loss = error_proc(Prob_images, right_label, ErrorPara) * 0.1 # 计算误差值
|
|
|
print("当前epoch:",first_epoch,i * batch_size,":",(i + 1) * batch_size,"误差值：",loss)
|
|
|
print("")
|
|
|
if Conv2 and Conv3 is None:
|
|
|
conv_one(loss, images)
|
|
|
elif Conv2 is not None and Conv3 is None:
|
|
|
conv_two(loss, images)
|
|
|
elif Conv3 is not None:
|
|
|
conv_three(loss, images)
|
|
|
# 输出模型程序
|
|
|
def model_show():
|
|
|
print(Items3)
|
|
|
|
|
|
def connecting_lines(obj_x, obj_y, index, x, y, x1, x2, y1, y2, y3 , image, text, smooth, width):
|
|
|
# 创建图元对象
|
|
|
Viewcanvas.create_image(obj_x+(index + x) * 80, obj_y, image=image)
|
|
|
# 创建图元对象的标签
|
|
|
Viewcanvas.create_text(obj_x+(index + x) * 80, obj_y + y1, text=text, font=("黑体", 8))
|
|
|
# 创建数据线箭头
|
|
|
Viewcanvas.create_line(obj_x+(index + x) * 80 +x1, obj_y + y2, obj_x+(index + y) * 80 +x2, obj_y + y3, arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=smooth, width=width)
|
|
|
|
|
|
def number_judgments(lsts):
|
|
|
global Items3
|
|
|
count = []
|
|
|
sequence = []
|
|
|
for index,lll in enumerate(lsts):
|
|
|
if type(lll) == list:
|
|
|
count.append(lll[1])
|
|
|
sequence.append(index)
|
|
|
if lll[1]==7:
|
|
|
break
|
|
|
count_2,count_3,count_4=0,0,0
|
|
|
list_count=[]
|
|
|
for i in count:
|
|
|
if i == 2:
|
|
|
count_2 += 1
|
|
|
list_count.append(i*10+count_2)
|
|
|
elif i == 3:
|
|
|
count_3 += 1
|
|
|
list_count.append(i * 10 + count_3)
|
|
|
elif i == 4:
|
|
|
count_4 += 1
|
|
|
list_count.append(i * 10 + count_4)
|
|
|
else:
|
|
|
list_count.append(i * 10)
|
|
|
Items3 = [0]
|
|
|
for i in count:
|
|
|
Items3.append(i - 1)
|
|
|
return count,list_count,sequence
|
|
|
def load_file():
|
|
|
filename = filedialog.askopenfilename(filetypes=[("Pickle files", "*.pkl")])
|
|
|
# 从本地文件中读取两个列表，用rb模式打开文件
|
|
|
with open(filename, "rb") as f:
|
|
|
# 创建一个空列表，用来存储读取的列表
|
|
|
lsts = []
|
|
|
# 用一个循环来读取所有的列表，直到文件结束
|
|
|
while True:
|
|
|
try:
|
|
|
# 读取一个列表，并追加到大列表中
|
|
|
lst = pickle.load(f)
|
|
|
lsts.append(lst)
|
|
|
except EOFError:
|
|
|
# 如果遇到文件结束的错误，就跳出循环
|
|
|
break
|
|
|
return lsts
|
|
|
|
|
|
def connecting(obj_x, obj_y, index, x, y1, image, text):
|
|
|
# 创建图元对象
|
|
|
Viewcanvas.create_image(obj_x+(index + x) * 80, obj_y, image=image)
|
|
|
# 创建图元对象的标签
|
|
|
Viewcanvas.create_text(obj_x+(index + x) * 80, obj_y + y1, text=text, font=("黑体", 8))
|
|
|
# 加载已有模型
|
|
|
def load_model():
|
|
|
import copy
|
|
|
lsts = load_file()
|
|
|
DataPara = setload_data()
|
|
|
global Train_images
|
|
|
global Test_images
|
|
|
global Viewcanvas
|
|
|
global Listinstance
|
|
|
global Viewcanvas
|
|
|
Viewcanvas.delete('all')
|
|
|
create_left_element(AllModelObj, List_image)
|
|
|
Train_images, Test_images = load_data(DataPara) # load_data()函数，根据参数加载数据集
|
|
|
# 打印一些信息，检查是否正确加载
|
|
|
print("训练集图片的形状：", Train_images.shape)
|
|
|
print("测试集图片的形状：", Test_images.shape)
|
|
|
# 根据pkl文件的前向传播顺序列表，依次识别卷积层、池化层、全连接层、非线性层和分类层的操作
|
|
|
count,counts,sequence = number_judgments(lsts)
|
|
|
x,y = 290,200
|
|
|
connecting_lines(x, y, 0, 0, 0, 25, 60, 45, 0, 0, List_image[0], '数据集', True, 1)
|
|
|
for layer in range(len(count)):
|
|
|
if count[layer] == 2: # 如果是卷积层，将读取的卷积层的信息存储到Conv实例
|
|
|
if counts[layer]%10 == 1:
|
|
|
global Conv1
|
|
|
Listinstance[1] = copy.deepcopy(lsts[sequence[layer]])
|
|
|
Conv1 = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[1], '卷积层1', True, 1)
|
|
|
if counts[layer]%10 == 2:
|
|
|
global Conv2
|
|
|
Conv2 = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[1], '卷积层2', True, 1)
|
|
|
if counts[layer]%10 == 3:
|
|
|
global Conv3
|
|
|
Conv3 = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[1], '卷积层3', True, 3)
|
|
|
if count[layer] == 3: # 如果是池化层，将读取的池化层的信息存储到Pool实例
|
|
|
if counts[layer]%10 == 1:
|
|
|
global Pool1
|
|
|
Listinstance[2] =copy.deepcopy(lsts[sequence[layer]])
|
|
|
Pool1 = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[2], '池化1', True, 3)
|
|
|
if counts[layer]%10 == 2:
|
|
|
global Pool2
|
|
|
Pool2 = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[2], '池化2', True, 3)
|
|
|
if counts[layer]%10 == 3:
|
|
|
global Pool3
|
|
|
Pool3 = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[2], '池化3', True, 3)
|
|
|
if count[layer] == 4: # 如果是全连接层，将读取的全连接层的信息存储到Pool实例
|
|
|
if counts[layer]%10 == 1:
|
|
|
global Fullconn1
|
|
|
Listinstance[3] = lsts[sequence[layer]]
|
|
|
Fullconn1 = copy.deepcopy(lsts[sequence[layer]])# 深拷贝创建了一个全新的对象,要使用深拷贝，不然报错
|
|
|
Listinstance[3][5] = str(Fullconn1[5][1]["num_outputs"])
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[3], '全连接1', True, 3)
|
|
|
if counts[layer]%10 == 2:
|
|
|
global Fullconn2
|
|
|
Fullconn2 = lsts[sequence[layer]]
|
|
|
# FullConn[5] = FullConn[5] + " " + str(Fullconn2[5][2]["num_outputs"])
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[3], '全连接3', True, 3)
|
|
|
if counts[layer]%10 == 3:
|
|
|
global Fullconn3
|
|
|
Fullconn3 = lsts[sequence[layer]]
|
|
|
# FullConn[5] = FullConn[5] + " " + str(Fullconn3[5][3]["num_outputs"])
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[3], '全连接3', True, 3)
|
|
|
if count[layer] == 5: # 如果是非线性层，将读取的非线性层的信息存储到Nonline实例
|
|
|
Listinstance[4] = lsts[sequence[layer]]
|
|
|
connecting_lines(x, y, layer, 1, 2, 25, -25, 45, 0, 0, List_image[4], '非线性', True, 3)
|
|
|
if count[layer] == 6: # 如果是分类输出层，将读取的信息存储到Nonline实例
|
|
|
Listinstance[5] = lsts[sequence[layer]]
|
|
|
connecting(x, y, layer, 1, 45,List_image[5], '分类')
|
|
|
if count[layer] == 7: # 如果是计算误差层，将读取的信息存储到Error实例
|
|
|
Listinstance[6] = lsts[sequence[layer]]
|
|
|
connecting(x - 30, y - 120, layer, 0, 45, List_image[6], '计算误差')
|
|
|
Viewcanvas.create_line(x + 5 * 80 + 25, y, x + 5 * 80 + 20, y - 80,
|
|
|
x + 5 * 80 - 20, y - 120, arrow=tk.LAST, arrowshape=(16, 20, 4),
|
|
|
fill='lightblue', smooth=True, width=1)
|
|
|
|
|
|
def create_window(number,count,list1,list2,list3,list4,list5,list6):
|
|
|
global Listinstance
|
|
|
if number == 1:
|
|
|
# 把数字的出现次数加一
|
|
|
count[number] = count.get(number, 0) + 1
|
|
|
if count[number] == 1:
|
|
|
# 获取第一层卷积层的参数
|
|
|
para_list = list1[count[number] - 1].split(",")
|
|
|
para_list = [int(x) for x in para_list]
|
|
|
window = creat_window('卷积1参数调整') # 创建一个新的窗口
|
|
|
kernel_size_entry = create_input_box(window, "卷积核大小：", para_list[0]) # 创建一个输入框，获取卷积核大小
|
|
|
stride_entry = create_input_box(window, "卷积步长：", para_list[1]) # 创建一个输入框，获取卷积步
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(kernel_size_entry.get())
|
|
|
result2 = int(stride_entry.get())
|
|
|
new_para = str(result1)+','+str(result2)
|
|
|
Listinstance[1][5] = Listinstance[1][5].replace(list1[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="卷积参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
if count[number] == 2:
|
|
|
# 获取第一层卷积层的参数
|
|
|
para_list = list1[count[number] - 1].split(",")
|
|
|
para_list = [int(x) for x in para_list]
|
|
|
window = creat_window('卷积2参数调整') # 创建一个新的窗口
|
|
|
kernel_size_entry = create_input_box(window, "卷积核大小：", para_list[0]) # 创建一个输入框，获取卷积核大小
|
|
|
stride_entry = create_input_box(window, "卷积步长：", para_list[1]) # 创建一个输入框，获取卷积步
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(kernel_size_entry.get())
|
|
|
result2 = int(stride_entry.get())
|
|
|
new_para = str(result1)+','+str(result2)
|
|
|
Listinstance[1][5] = Listinstance[1][5].replace(list1[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="卷积参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
if count[number] == 3:
|
|
|
# 获取第一层卷积层的参数
|
|
|
para_list = list1[count[number] - 1].split(",")
|
|
|
para_list = [int(x) for x in para_list]
|
|
|
# 创建一个输入框，获取卷积核大小
|
|
|
window = creat_window('卷积3参数调整') # 创建一个新的窗口
|
|
|
kernel_size_entry = create_input_box(window, "卷积核大小：", para_list[0]) # 创建一个输入框，获取卷积核大小
|
|
|
stride_entry = create_input_box(window, "卷积步长：", para_list[1]) # 创建一个输入框，获取卷积步
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(kernel_size_entry.get())
|
|
|
result2 = int(stride_entry.get())
|
|
|
new_para = str(result1)+','+str(result2)
|
|
|
Listinstance[1][5] = Listinstance[1][5].replace(list1[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="卷积参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
# 返回窗口对象
|
|
|
return window
|
|
|
# 如果是池化层
|
|
|
if number == 2:
|
|
|
# 把数字的出现次数加一
|
|
|
count[number] = count.get(number, 0) + 1
|
|
|
if count[number] == 1:
|
|
|
# 获取第一层卷积层的参数
|
|
|
para_list = list2[count[number] - 1].split(",")
|
|
|
para_list[1] = int(para_list[1])
|
|
|
window = creat_window('池化1参数调整') # 创建一个新的窗口
|
|
|
pool_type_combobox = create_dropdown_box(window, "池化池类型：", ["max", "avg", "min"]) # 创建一个下拉框，用于选择池化类型
|
|
|
pool_size_entry = create_input_box(window, "池化池大小：", para_list[1]) # 创建一个输入框，获取卷积步
|
|
|
def modify_para():
|
|
|
# 从下拉框中获取池化类型
|
|
|
pool_type = pool_type_combobox.get()
|
|
|
# 从输入框中获取池大小
|
|
|
pool_size = int(pool_size_entry.get())
|
|
|
# 关闭窗口
|
|
|
new_para = str(pool_type)+','+str(pool_size)
|
|
|
Listinstance[2][5] = Listinstance[2][5].replace(list2[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="池化参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
if count[number] == 2:
|
|
|
# 获取第一层卷积层的参数
|
|
|
para_list = list2[count[number] - 1].split(",")
|
|
|
para_list[1] = int(para_list[1])
|
|
|
window = creat_window('池化2参数调整') # 创建一个新的窗口
|
|
|
pool_type_combobox = create_dropdown_box(window, "池化池类型：", ["max", "avg", "min"]) # 创建一个下拉框，用于选择池化类型
|
|
|
pool_size_entry = create_input_box(window, "池化池大小：", para_list[1]) # 创建一个输入框，获取卷积步
|
|
|
def modify_para():
|
|
|
# 从下拉框中获取池化类型
|
|
|
pool_type = pool_type_combobox.get()
|
|
|
# 从输入框中获取池大小
|
|
|
pool_size = int(pool_size_entry.get())
|
|
|
# 关闭窗口
|
|
|
new_para = str(pool_type)+','+str(pool_size)
|
|
|
Listinstance[2][5] = Listinstance[2][5].replace(list2[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="池化参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
if count[number] == 3:
|
|
|
# 获取第一层卷积层的参数
|
|
|
para_list = list2[count[number] - 1].split(",")
|
|
|
para_list[1] = int(para_list[1])
|
|
|
window = creat_window('池化3参数调整') # 创建一个新的窗口
|
|
|
pool_type_combobox = create_dropdown_box(window, "池化池类型：", ["max", "avg", "min"]) # 创建一个下拉框，用于选择池化类型
|
|
|
pool_size_entry = create_input_box(window, "池化池大小：", para_list[1]) # 创建一个输入框，获取卷积步
|
|
|
def modify_para():
|
|
|
# 从下拉框中获取池化类型
|
|
|
pool_type = pool_type_combobox.get()
|
|
|
# 从输入框中获取池大小
|
|
|
pool_size = int(pool_size_entry.get())
|
|
|
# 关闭窗口
|
|
|
new_para = str(pool_type)+','+str(pool_size)
|
|
|
Listinstance[2][5] = Listinstance[2][5].replace(list2[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="池化参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
# 返回窗口对象
|
|
|
return window
|
|
|
if number == 3:
|
|
|
# 把数字的出现次数加一
|
|
|
count[number] = count.get(number, 0) + 1
|
|
|
if count[number] == 1:
|
|
|
# 获取第一层全连接层的参数
|
|
|
para = list3[count[number] - 1]
|
|
|
para = int(para)
|
|
|
window = creat_window('全连接1参数调整') # 创建一个新的窗口
|
|
|
num_outputs_entry = create_input_box(window, "输出维度：", para) # 创建一个输入框，获取卷积步
|
|
|
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
num = int(num_outputs_entry.get())
|
|
|
new_para = str(num)
|
|
|
Listinstance[3][5] = Listinstance[3][5].replace(list3[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="全连接参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
if count[number] == 2:
|
|
|
# 获取第一层全连接层的参数
|
|
|
para = list3[count[number] - 1]
|
|
|
para = int(para)
|
|
|
window = creat_window('全连接2参数调整') # 创建一个新的窗口
|
|
|
num_outputs_entry = create_input_box(window, "输出维度：", para) # 创建一个输入框，获取全连接
|
|
|
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
num = int(num_outputs_entry.get())
|
|
|
new_para = str(num)
|
|
|
Listinstance[3][5] = Listinstance[3][5].replace(list3[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="全连接参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
if count[number] == 3:
|
|
|
# 获取第一层全连接层的参数
|
|
|
para = list3[count[number] - 1]
|
|
|
para = int(para)
|
|
|
window = creat_window('全连接3参数调整') # 创建一个新的窗口
|
|
|
num_outputs_entry = create_input_box(window, "输出维度：", para) # 创建一个输入框，获取全连接
|
|
|
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
num = int(num_outputs_entry.get())
|
|
|
new_para = str(num)
|
|
|
Listinstance[3][5] = Listinstance[3][5].replace(list3[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="全连接参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
# 返回窗口对象
|
|
|
return window
|
|
|
if number == 4:
|
|
|
# 把数字的出现次数加一
|
|
|
count[number] = count.get(number, 0) + 1
|
|
|
if count[number] == 1:
|
|
|
# 获取第一层非线性层的参数
|
|
|
para = list3[count[number] - 1]
|
|
|
window = creat_window('非线性1参数调整') # 创建一个新的窗口
|
|
|
nonlinear_mode_combobox = create_dropdown_box(window, "非线性类型：",
|
|
|
["Sigmoid", "ReLU", "Tanh"]) # 创建一个下拉框，用于选择非线性类型
|
|
|
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
nonlinear_mode = nonlinear_mode_combobox.get()
|
|
|
new_para = str(nonlinear_mode)
|
|
|
Listinstance[4][5] = Listinstance[4][5].replace(list4[count[number] - 1], new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="非线性参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
# 返回窗口对象
|
|
|
return window
|
|
|
if number == 5:
|
|
|
# 把数字的出现次数加一
|
|
|
count[number] = count.get(number, 0) + 1
|
|
|
if count[number] == 1:
|
|
|
# 获取分类的参数
|
|
|
para = list5
|
|
|
para = float(para)
|
|
|
window = creat_window('分类参数调整') # 创建一个新的窗口
|
|
|
threshold_entry = create_input_box(window, "阈值：", para) # 创建一个输入框，用于输入阈值
|
|
|
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
threshold = threshold_entry.get()
|
|
|
new_para = str(threshold)
|
|
|
Listinstance[5][5] = Listinstance[5][5].replace(list5, new_para)
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="分类参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
# 返回窗口对象
|
|
|
return window
|
|
|
if number == 6:
|
|
|
# 把数字的出现次数加一
|
|
|
count[number] = count.get(number, 0) + 1
|
|
|
if count[number] == 1:
|
|
|
# 获取分类的参数
|
|
|
para = list6
|
|
|
window = creat_window('误差参数调整') # 创建一个新的窗口
|
|
|
loss_type_combobox = create_dropdown_box(window, "误差类型：",
|
|
|
["CEE", "MSE", "MAE"]) # 创建一个下拉框，用于选择误差类型
|
|
|
def modify_para():
|
|
|
# 获取输入框的内容
|
|
|
loss_type = loss_type_combobox.get()
|
|
|
new_para = str(loss_type)
|
|
|
Listinstance[6][5] = Listinstance[6][5].replace(list6[count[number] - 1], new_para)
|
|
|
# print(Listinstance[6])
|
|
|
# 关闭窗口
|
|
|
window.destroy()
|
|
|
|
|
|
# 创建一个按钮，文本为数字
|
|
|
button = tk.Button(window, text="误差参数修改")
|
|
|
# 绑定按钮的点击事件，使得点击后销毁窗口
|
|
|
button.config(command=modify_para)
|
|
|
# 把按钮放在窗口中
|
|
|
button.pack()
|
|
|
return window # 返回窗口对象
|
|
|
|
|
|
# 清空当前模型展示区
|
|
|
def restart_new_model():
|
|
|
# 这将在子进程中调用当前Python解释器，并传递当前文件的路径作为参数
|
|
|
subprocess.call([sys.executable, __file__])
|
|
|
|
|
|
def setpara_func(): # 图元参数配置与修改
|
|
|
global Viewcanvas
|
|
|
# 一个字典，用来记录每个数字出现的次数
|
|
|
count = {}
|
|
|
list1 = Listinstance[1][5].split()
|
|
|
list2 = Listinstance[2][5].split()
|
|
|
list3 = Listinstance[3][5].split()
|
|
|
list4 = Listinstance[4][5].split()
|
|
|
list5 = Listinstance[5][5]
|
|
|
list6 = Listinstance[6][5].split()
|
|
|
for i in Items4: # 清除所有文字标签
|
|
|
Viewcanvas.delete(i[0])
|
|
|
numbers = [x for x in Items3 if x <= 6] # 一个函数，用来创建一个带有一个数字标签的按钮的窗口
|
|
|
numbers = numbers[1:]
|
|
|
def iterate_numbers(): # 一个函数，用来遍历数字列表，依次创建窗口
|
|
|
if numbers: # 如果数字列表不为空
|
|
|
number = numbers.pop(0) # 从列表中弹出第一个数字
|
|
|
window = create_window(number, count, list1, list2, list3, list4, list5, list6)
|
|
|
window.wait_window() # 等待窗口被关闭
|
|
|
iterate_numbers() # 再次调用这个函数，创建下一个窗口
|
|
|
|
|
|
iterate_numbers() # 调用遍历数字的函数
|
|
|
'''
|
|
|
【编程16.20】编制程序：输出函数。
|
|
|
【目的及编程说明】读者通过编程16.20，可掌握图片分类过程。该函数的输入为1000幅图像的集合，输出为模型结构（模型的参数）。
|
|
|
基本实践内容：
|
|
|
（1）定义输入数据格式，即图像数据的维度和格式，然后加载数据集对象，使用加载数据集对象的ProcFunc将图像数据加载到网络模型中。
|
|
|
（2）使用SetParaFunc函数对每个节点进行参数赋值，通过AllModelConn表中的连接信息，使用训练好的神经网络进行预测。
|
|
|
（3）计算预测误差：使用AllModelObj表中的ProcFunc函数对预测结果与真实标签进行比较，计算误差。
|
|
|
（4）进行网络优化：使用AllModelObj表中的ProcFunc函数对误差进行反向传播，并调整神经网络中的参数和连接权重，以最小化误差。
|
|
|
（5）使用AllModelObj表中的ProcFunc函数对1000幅图像数据进行分类，得到最终的分类结果。
|
|
|
'''
|
|
|
|
|
|
def count_model(layer):
|
|
|
# 如果layer是第一次出现，就把它加入字典，并设置计数器为1
|
|
|
if layer not in Counts:
|
|
|
Counts[layer] = 1
|
|
|
# 如果layer已经出现过，就把它的计数器加一
|
|
|
else:
|
|
|
Counts[layer] += 1
|
|
|
# 如果是卷积层
|
|
|
if layer == 1:
|
|
|
if Counts[layer] == 1:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Conv1, f)
|
|
|
elif Counts[layer] == 2:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Conv2, f)
|
|
|
elif Counts[layer] == 3:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Conv3, f)
|
|
|
# 如果是池化层
|
|
|
if layer == 2:
|
|
|
if Counts[layer] == 1:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Pool1, f)
|
|
|
elif Counts[layer] == 2:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Pool2, f)
|
|
|
elif Counts[layer] == 3:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Pool3, f)
|
|
|
# 如果是全连接层
|
|
|
if layer == 3:
|
|
|
if Counts[layer] == 1:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Fullconn1, f)
|
|
|
elif Counts[layer] == 2:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Fullconn2, f)
|
|
|
elif Counts[layer] == 3:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Fullconn3, f)
|
|
|
# 如果是非线性处理层
|
|
|
if layer == 4:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Listinstance[4], f)
|
|
|
# 如果是输出分类层
|
|
|
if layer == 5:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Listinstance[5], f)
|
|
|
# 如果是计算误差层
|
|
|
if layer == 6:
|
|
|
with open("list.pkl", "ab") as f:
|
|
|
pickle.dump(Listinstance[6], f)
|
|
|
|
|
|
# 保存网络模型
|
|
|
def save_model():
|
|
|
if len(Items3) == 0:
|
|
|
messagebox.showerror("错误", "请添加图元！")
|
|
|
return
|
|
|
# 生成试验数据集，用于保存模型
|
|
|
Test_images = np.random.rand(100, 48, 48) * 0.01
|
|
|
# 对试验数据集进行前向传播的计算
|
|
|
print(forward_propagation(Test_images))
|
|
|
# 打开一个本地文件，用w模式或者wb模式
|
|
|
with open("model.pkl", "wb") as f:
|
|
|
pickle.dump(Items3, f)# 保存模型
|
|
|
# 遍历网络结构
|
|
|
for layer in Items3[1:]:
|
|
|
count_model(layer)
|
|
|
messagebox.showinfo("成功", "保存正确，恭喜！")
|
|
|
|
|
|
def check_connection():
|
|
|
connection = [x for x in Items3 if x < 6]
|
|
|
length = len(connection)
|
|
|
if length == 0:
|
|
|
messagebox.showerror("错误", "请添加图元！")
|
|
|
return
|
|
|
for i in range(length-1):
|
|
|
right_model_x = connection[i]
|
|
|
right_model_y = connection[i+1]
|
|
|
if RIGHT_MODEL[right_model_x][right_model_y] == 0:
|
|
|
messagebox.showerror("错误", "连接不正确，请检查！")
|
|
|
return
|
|
|
messagebox.showinfo("成功", "连接正确，恭喜！")
|
|
|
|
|
|
def redirector(inputStr):
|
|
|
global Text
|
|
|
Text.configure(state="normal") # 设置文本框为可编辑状态
|
|
|
Text.insert("end", inputStr) # 在文本框末尾插入内容
|
|
|
Text.see("end") # 滚动到末尾
|
|
|
Text.configure(state="disabled") # 设置文本框为只读状态
|
|
|
|
|
|
def close_program():
|
|
|
sys.exit()
|
|
|
|
|
|
def button_link():
|
|
|
global button
|
|
|
# 替每个主界面的按钮绑定各自的函数
|
|
|
button['button1'].config(command=train_setting)
|
|
|
button['button2'].config(command=train) # 训练
|
|
|
button['button3'].config(command=model_show) # 训练
|
|
|
button['button4'].config(command=load_model) # 训练
|
|
|
button['button5'].config(command=restart_new_model) # 训练
|
|
|
button['button6'].config(command=setpara_func) # 训练
|
|
|
button['button7'].config(command=save_model) # 保存模型
|
|
|
button['button8'].config(command=check_connection)
|
|
|
button['button9'].config(command=close_program)
|
|
|
|
|
|
def main():
|
|
|
# X1-X2编制赋值程序及输出界面
|
|
|
# 创建一个主窗口
|
|
|
global Root
|
|
|
global Listinstance
|
|
|
global List_image
|
|
|
global AllModelObj
|
|
|
global button
|
|
|
Root = tk.Tk()
|
|
|
# 设置窗口的大小为1200*750
|
|
|
window_width = 800 # 窗口的宽度
|
|
|
window_height = 450 # 窗口的高度
|
|
|
Root.title("神经网络可视化")
|
|
|
Root.geometry("800x450") # 设置窗口的大小和位置
|
|
|
picture_frame(window_width, window_height)
|
|
|
Listinstance = create_instance()
|
|
|
# 创建网络对象总表和网络连接对象总表
|
|
|
AllModelObj = [Listinstance[0], Listinstance[1], Listinstance[2], Listinstance[3], Listinstance[4], Listinstance[5],
|
|
|
Listinstance[6], Listinstance[7], Listinstance[8], Listinstance[9]]
|
|
|
|
|
|
img_path = ["img/data.png", "img/conv.png", "img/pool.png", "img/full_connect.png", "img/nonlinear.png",
|
|
|
"img/classifier.png", "img/error.png", "img/adjust.png", "img/arrow1.png", "img/arrow2.png"]
|
|
|
List_image = []
|
|
|
for path in img_path:
|
|
|
List_image.append(element(path))
|
|
|
button = push_button()
|
|
|
create_left_element(AllModelObj, List_image)
|
|
|
button_link()
|
|
|
sys.stdout.write = redirector
|
|
|
Root.mainloop()
|
|
|
if __name__ == '__main__':
|
|
|
main() |
