|
|
import math
|
|
|
import os
|
|
|
import re
|
|
|
|
|
|
import cv2
|
|
|
import numpy as np
|
|
|
import tkinter as tk
|
|
|
from tkinter import filedialog
|
|
|
from read_data import *
|
|
|
from PIL import Image
|
|
|
# from X1 import *
|
|
|
import shutil
|
|
|
import sys
|
|
|
import pickle
|
|
|
import subprocess
|
|
|
import textwrap
|
|
|
|
|
|
import numpy as np
|
|
|
import pandas as pd
|
|
|
import tkinter as tk
|
|
|
from tkinter import ttk
|
|
|
# from ttkbootstrap import Style
|
|
|
from tkinter import messagebox
|
|
|
import tkinter.scrolledtext as st
|
|
|
from PIL import Image, ImageTk
|
|
|
from matplotlib import pyplot as plt
|
|
|
from tkinter import Canvas, Frame, BOTH, PhotoImage, filedialog
|
|
|
|
|
|
class Interactive_CNN:
|
|
|
def __init__(self):
|
|
|
self.Dragged_item = () # 记录被拖拽的图元id
|
|
|
self.Yt = 0 # 新图元的y坐标
|
|
|
self.Original_x = 0 # 记录图元原来的x坐标
|
|
|
self.Original_y = 0 # 记录图元原来的y坐标
|
|
|
self.Offset_x = 0 # 记录鼠标相对于图元的x偏移量
|
|
|
self.Offset_y = 0 # 记录鼠标相对于图元的y偏移量
|
|
|
self.Root = tk.Tk()
|
|
|
# 设置窗口的大小为1200*750
|
|
|
window_width = 1400 # 窗口的宽度
|
|
|
window_height = 900 # 窗口的高度
|
|
|
self.Root.title("神经网络可视化")
|
|
|
self.Root.geometry("1400x900") # 设置窗口的大小和位置
|
|
|
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/adjust.png", "img/adjust.png", "img/arrow1.png", "img/arrow2.png"]
|
|
|
self.List_image = []
|
|
|
for path in img_path[:-2]:
|
|
|
self.List_image.append(self.element(path, 70, 60))
|
|
|
self.List_image.append(self.element(img_path[-2], 70, 30))
|
|
|
self.List_image.append(self.element(img_path[-1], 70, 30))
|
|
|
# 创建一个画布，用于绘制矩形框，设置画布的大小和背景色
|
|
|
self.Viewcanvas = tk.Canvas(self.Root, width=window_width, height=window_height, bg="white")
|
|
|
self.Viewcanvas.pack() # 将画布添加到主窗口中
|
|
|
# 绘制矩形框，使用不同的颜色和线宽，指定矩形框的左上角和右下角坐标，填充色，边框色和边框宽度
|
|
|
self.Viewcanvas.create_rectangle(20, 20, 370, 580, fill=None, outline="lightblue", width=2)
|
|
|
self.Viewcanvas.create_rectangle(380, 40, 1390, 580, fill=None, outline="lightblue", width=2)
|
|
|
self.Viewcanvas.create_rectangle(20, 620, 1390, 880, fill=None, outline="lightblue", width=2)
|
|
|
self.Text = st.ScrolledText(self.Root) # 创建一个带滚动条的文本框，用于展示计算过程
|
|
|
self.Text.place(x=20, y=620, width=1365, height=260)
|
|
|
self.button = {}
|
|
|
# 按钮顺序：加载已有模型、新建模型、图元参数设置、保存模型、模型正确性检查、退出、训练参数设置、训练、输出模型程序
|
|
|
names = ['加载已有模型', '新建模型', '图元参数设置', '保存模型', '模型正确性检查', '退出', '训练参数设置', '训练', '输出模型程序']
|
|
|
positions = [(385, 10), (590, 10), (760, 10), (950, 10), (1100, 10), (1310, 10), (20, 590), (200, 590),
|
|
|
(300, 590)]
|
|
|
bg = ['#32CD32', '#32CD32', '#32CD32', '#32CD32', '#32CD32', '#FF0000', '#436EEE', '#436EEE', '#436EEE']
|
|
|
for i in range(9):
|
|
|
button = tk.Button(self.Root, text=' '+names[i]+' ', bg=bg[i], bd=0, relief=tk.FLAT,
|
|
|
highlightthickness=0, font=("黑体", 14))
|
|
|
button.place(x=positions[i][0], y=positions[i][1])
|
|
|
self.button['button' + str(i+1)] = button
|
|
|
def button_link(self):
|
|
|
# 替每个主界面的按钮绑定各自的函数
|
|
|
self.button['button1'].config(command=Mod.load_model) # 加载已有模型
|
|
|
self.button['button2'].config(command=self.restart_new_model) # 新建模型
|
|
|
self.button['button3'].config(command=Net.setpara_func) # 图元参数设置
|
|
|
self.button['button4'].config(command=Mod.save_model) # 保存模型
|
|
|
self.button['button5'].config(command=Net.check_connection) # 模型正确性检查
|
|
|
self.button['button6'].config(command=self.close_program) # 退出
|
|
|
self.button['button7'].config(command=Mod.train_setting) # 训练参数
|
|
|
self.button['button8'].config(command=Mod.train) # 训练
|
|
|
def close_program(self):
|
|
|
sys.exit()
|
|
|
|
|
|
|
|
|
def element(self, path, width, height):
|
|
|
# 加载图元对应的图片文件
|
|
|
img = Image.open(path)
|
|
|
# 使用resize方法调整图片
|
|
|
img = img.resize((width, height))
|
|
|
# 把Image对象转换成PhotoImage对象
|
|
|
img = ImageTk.PhotoImage(img)
|
|
|
# 保存图片的引用，防止被垃圾回收
|
|
|
self.Root.img = img
|
|
|
return img
|
|
|
|
|
|
def redirector(self, inputStr):
|
|
|
self.Text.configure(state="normal") # 设置文本框为可编辑状态
|
|
|
self.Text.insert("end", inputStr) # 在文本框末尾插入内容
|
|
|
self.Text.see("end") # 滚动到末尾
|
|
|
self.Text.configure(state="disabled") # 设置文本框为只读状态
|
|
|
|
|
|
def create_left_element(self, List_image):
|
|
|
# 图元列表，在窗口左侧创建图元菜单、
|
|
|
element_list = [(135, 60), (320, 60), (135, 156), (320, 156), (135, 252), (320, 252),
|
|
|
(135, 348), (320, 348), (135, 444), (320, 444), (135, 540), (320, 540)]
|
|
|
for i in range(12):
|
|
|
# 获取图元对象的类型、标签等信息
|
|
|
obj_type = i+1
|
|
|
# 并且要根据需求调整每个对象的位置
|
|
|
obj_x = element_list[i][0] # 根据对象的id计算x坐标
|
|
|
obj_y = element_list[i][1] # 根据对象的id计算y坐标
|
|
|
# 根据对象的类型，绘制相应的图形
|
|
|
if obj_type == 1: # 加载数据集
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[0], 3, " 加载" + "\n" + "数据集")
|
|
|
elif obj_type == 2: # 卷积
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[1], 0, "卷积")
|
|
|
elif obj_type == 3: # 池化
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[2], 0, "池化")
|
|
|
elif obj_type == 4: # 全连接
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[3], 0, "全连接" + "\n" + " 函数")
|
|
|
elif obj_type == 5: # 非线性
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[4], 0, "非线性" + "\n" + " 函数")
|
|
|
elif obj_type == 6: # 分类
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[5], 0, "类别")
|
|
|
elif obj_type == 7: # 误差计算
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[6], 0, "误差")
|
|
|
elif obj_type == 8: # 调整
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[7], 0, "调整1")
|
|
|
elif obj_type == 9: # 调整
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[8], 0, "调整2")
|
|
|
elif obj_type == 10: # 调整
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[9], 0, "调整3")
|
|
|
elif obj_type == 11: # 调整
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[10], 3, "主数据" + "\n" + "连接线")
|
|
|
elif obj_type == 12: # 调整
|
|
|
l1 = self.element_binding(obj_x, obj_y, List_image[11], 3, " 参数" + "\n" + "连接线")
|
|
|
# 为左边菜单的每个图元绑定鼠标按下、移动和松开的事件
|
|
|
self.Viewcanvas.tag_bind(l1, "<Button-1>", self.on_drag_start)
|
|
|
self.Viewcanvas.tag_bind(l1, "<B1-Motion>", self.on_drag_motion)
|
|
|
self.Viewcanvas.tag_bind(l1, "<ButtonRelease-1>", self.on_drag_end)
|
|
|
|
|
|
def element_binding(self, obj_x, obj_y, image, y, text):
|
|
|
l1 = self.Viewcanvas.create_image(obj_x, obj_y, image=image) # 创建图元对象
|
|
|
# 创建图元对象的标签
|
|
|
self.Viewcanvas.create_text(obj_x - 80, obj_y + y, text=text, font=("黑体", 14))
|
|
|
return l1
|
|
|
|
|
|
# 定义图元拖拽开始的函数
|
|
|
def on_drag_start(self, event):
|
|
|
# 获取当前图元的id
|
|
|
# 这个物体的id是由tkinter自动分配的。当在画布上创建一个物体时，它会返回一个唯一的整数id，可以用它来引用这个物体
|
|
|
self.Dragged_item = event.widget.find_closest(event.x, event.y)
|
|
|
|
|
|
self.Original_x = event.widget.coords(self.Dragged_item)[0] # 获取当前图元的x坐标
|
|
|
self.Original_y = event.widget.coords(self.Dragged_item)[1] # 获取当前图元的y坐标
|
|
|
self.Offset_x = self.Original_x - event.x # 计算鼠标相对于图元的x偏移量
|
|
|
self.Offset_y = self.Original_y - event.y # 计算鼠标相对于图元的y偏移量
|
|
|
|
|
|
# 定义图元拖拽移动的函数
|
|
|
def on_drag_motion(self, event):
|
|
|
x = event.x + self.Offset_x # 计算图元新的x坐标
|
|
|
y = event.y + self.Offset_y # 计算图元新的y坐标
|
|
|
event.widget.coords(self.Dragged_item, x, y) # 更新图元的位置
|
|
|
# 定义图元拖拽结束的函数
|
|
|
def on_drag_end(self, event):
|
|
|
obj_id1 = self.Dragged_item[0] # 获取被拖拽的图元的id
|
|
|
# 使用 print(obj_id1) 从而查看各个图元的id,此步省略
|
|
|
# 根据图元的类型，复制相应的图片到右侧画布
|
|
|
self.on_drag(obj_id1, event)
|
|
|
|
|
|
def on_drag(self, obj_id1, event): # 左侧函数绑定
|
|
|
if obj_id1 == 4: # 数据集
|
|
|
# 调用 entity_loading_dataset 方法
|
|
|
Net.entity_loading_dataset(event)
|
|
|
elif obj_id1 == 6: # 卷积
|
|
|
# 调用 convolution 方法
|
|
|
Net.convolution(event)
|
|
|
elif obj_id1 == 8: # 池化
|
|
|
# 调用 pooling 方法
|
|
|
Net.pooling(event)
|
|
|
elif obj_id1 == 10: # 全连接
|
|
|
# 调用 fully_connected 方法
|
|
|
Net.fully_connected(event)
|
|
|
elif obj_id1 == 12: # 非线性
|
|
|
# 调用 nonlinear 方法
|
|
|
Net.nonlinear(event)
|
|
|
elif obj_id1 == 14: # 分类
|
|
|
# 调用 class_ification 方法
|
|
|
Net.class_ification(event)
|
|
|
elif obj_id1 == 16: # 误差
|
|
|
# 调用 error_calculation 方法
|
|
|
Net.error_calculation(event)
|
|
|
elif obj_id1 == 18: # 调整1
|
|
|
# 调用 adjust_one 方法
|
|
|
Net.adjust_one(event)
|
|
|
elif obj_id1 == 20: # 调整2
|
|
|
# 调用 adjust_two 方法
|
|
|
Net.adjust_two(event)
|
|
|
elif obj_id1 == 22: # 调整3
|
|
|
# 调用 adjust_three 方法
|
|
|
Net.adjust_three(event)
|
|
|
elif obj_id1 == 24: # 主数据线
|
|
|
# 调用 main_line 方法，参数为 1
|
|
|
Net.main_line(event, 1)
|
|
|
elif obj_id1 == 26: # 参数数据线
|
|
|
# 调用 main_line 方法，参数为 0
|
|
|
Net.main_line(event, 0)
|
|
|
|
|
|
# 创建弹出窗口
|
|
|
def creat_window(self, title):
|
|
|
top = tk.Toplevel(self.Root)
|
|
|
top.geometry("300x350")
|
|
|
top.title(title)
|
|
|
return top
|
|
|
|
|
|
# 输入框
|
|
|
def create_input_box(self, top, text, value):
|
|
|
# 创建一个标签，显示指定的文本
|
|
|
box_label = tk.Label(top, text=text)
|
|
|
box_label.pack(padx=10, pady=10) # 设置标签的外边距
|
|
|
# 创建一个 IntVar 对象，并设置默认值为传入的 value 参数
|
|
|
box_size = tk.IntVar(top, value=value)
|
|
|
# 创建一个输入框，并关联到上面创建的 IntVar 对象
|
|
|
box_size_entry = tk.Entry(top, textvariable=box_size)
|
|
|
# 设置输入框的外边距
|
|
|
box_size_entry.pack(padx=20, pady=20)
|
|
|
# 返回创建的输入框，以便在调用该方法的地方使用
|
|
|
return box_size_entry
|
|
|
|
|
|
def create_dropdown_box(self, top, text, listvalues, default_value):
|
|
|
# 创建一个标签，显示指定的文本
|
|
|
box_mode_label = tk.Label(top, text=text)
|
|
|
box_mode_label.pack(padx=10, pady=10) # 设置标签的外边距
|
|
|
# 创建一个下拉框（Combobox），用于选择
|
|
|
box_mode_combobox = ttk.Combobox(top)
|
|
|
# 设置下拉框的可选值
|
|
|
box_mode_combobox["values"] = listvalues
|
|
|
# 设置下拉框的默认值
|
|
|
box_mode_combobox.set(default_value)
|
|
|
# 设置下拉框的外边距
|
|
|
box_mode_combobox.pack(padx=20, pady=15)
|
|
|
# 返回创建的下拉框对象，以便在调用该方法的地方使用
|
|
|
return box_mode_combobox
|
|
|
|
|
|
# 清空当前模型展示区
|
|
|
def restart_new_model(self):
|
|
|
# 这将在子进程中调用当前Python解释器，并传递当前文件的路径作为参数
|
|
|
subprocess.call([sys.executable, __file__])
|
|
|
|
|
|
class ModelConn:
|
|
|
def __init__(self, ConnObjID, ConnType, NobjS, NobjE):
|
|
|
self.ConnObjID = ConnObjID # 连接线编号
|
|
|
self.ConnType = ConnType # 连接线类别
|
|
|
self.NobjS = NobjS # 源图元对象
|
|
|
self.NobjE = NobjE # 目标图元对象
|
|
|
|
|
|
def output(self): # 输出方法
|
|
|
# 创建一个空列表
|
|
|
result = [self.ConnObjID, self.ConnType, self.NobjS, self.NobjE]
|
|
|
return result
|
|
|
|
|
|
class Networking:
|
|
|
def __init__(self):
|
|
|
self.AllModelObj = [] # 网络对象总表
|
|
|
self.AllModelConn = [] # 网络连接对象总表
|
|
|
self.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]
|
|
|
]
|
|
|
self.Items1 = [] # 存储被拖拽的图元的列表
|
|
|
self.Second_Items = [[], [], []] # 记录第二个框中画布创建的序号(图元，标签，连线）
|
|
|
self.SubFolders = [] # 存储数据集类别
|
|
|
self.Element = [] # 记录图元名称
|
|
|
self.Train_images = [] # 存储训练集的列表
|
|
|
self.Test_images = [] # 存储测试集的列表
|
|
|
self.ImgPath = [] # 储存数据集路径
|
|
|
self.Item_Record = []
|
|
|
self.Item_Name = []
|
|
|
|
|
|
def entity_loading_dataset(self, event):
|
|
|
CNN.Yt = event.y + CNN.Offset_y
|
|
|
i, x, y = self.element_adjustment(event, True, '数据集', 0)
|
|
|
name = '数据集' if i == 1 else '数据集' + str(i)
|
|
|
# 复制图元对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, y + 45, text=name), name])
|
|
|
|
|
|
DataSet = Data_Class("DataSet" + str(i), 1, '数据集' + str(i), ".", x, y)
|
|
|
self.AllModelObj.append(DataSet)
|
|
|
# 创建一个tkinter根窗口，并隐藏它
|
|
|
root1 = tk.Tk()
|
|
|
root1.withdraw()
|
|
|
# setload_data()函数，获取加载数据集的参数
|
|
|
DataPara = DataSet.SetDataPara()
|
|
|
self.ImgPath.append(DataPara['train_imgPath'])
|
|
|
self.ImgPath.append(DataPara['test_imgPath'])
|
|
|
# 调用X3中load_data()函数，根据参数加载数据集
|
|
|
self.Train_images, self.Test_images = DataSet.LoadData(DataPara)
|
|
|
# 打印一些信息，检查是否正确加载
|
|
|
print("训练集图片的形状：", self.Train_images.shape)
|
|
|
DataSet.images_statistics(DataPara['train_imgPath'])
|
|
|
print("测试集图片的形状：", self.Test_images.shape)
|
|
|
DataSet.images_statistics(DataPara['test_imgPath'])
|
|
|
|
|
|
def convolution(self, event):
|
|
|
i, x, y = self.element_adjustment(event, True, '卷积', 1)
|
|
|
|
|
|
Conv = Conv_Class("Conv" + str(i), 2, "卷积"+str(i), [], x, CNN.Yt)
|
|
|
self.AllModelObj.append(Conv)
|
|
|
top = CNN.creat_window('卷积参数配置') # 创建弹出窗口
|
|
|
kernel_size_entry = CNN.create_input_box(top, "卷积核大小：", 3) # 创建一个输入框，获取卷积核大小
|
|
|
stride_entry = CNN.create_input_box(top, "卷积步长：", 1) # 创建一个输入框，获取卷积步长
|
|
|
name = '卷积:' if i == 1 else '卷积' + str(i) + ':'
|
|
|
def get_input(): # 创建
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(kernel_size_entry.get())
|
|
|
result2 = int(stride_entry.get())
|
|
|
text = str(result1) + "*" + str(result1)
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name+text), name]) # 复制图元对象的标签
|
|
|
# 参数赋值
|
|
|
self.AllModelObj[-1].ParaString.append([result1, result2])
|
|
|
self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetConvPara(self.AllModelObj[-1]))
|
|
|
# print(self.AllModelObj[-1].ParaString)
|
|
|
top.destroy() # 关闭窗口
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def pooling(self, event):
|
|
|
i, x, y = self.element_adjustment(event, True, '池化', 2)
|
|
|
|
|
|
Pool = Pool_Class("Pool" + str(i), 3, "池化" + str(i), [], x, CNN.Yt)
|
|
|
self.AllModelObj.append(Pool)
|
|
|
# 创建弹出窗口
|
|
|
top = CNN.creat_window("池化参数配置")
|
|
|
pool_type_combobox = CNN.create_dropdown_box(top, "池化池类型：", ["max", "avg", "min"], 'max') # 创建一个下拉框，用于选择池化类型
|
|
|
pool_size_entry = CNN.create_input_box(top, "池化池大小：", 2) # 创建一个输入框，用于输入池大小
|
|
|
name = '池化:' if i == 1 else '池化' + str(i) + ':'
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 从下拉框中获取池化类型
|
|
|
pool_type = pool_type_combobox.get()
|
|
|
# 从输入框中获取池大小
|
|
|
pool_size = int(pool_size_entry.get())
|
|
|
text = str(pool_size) + "*" + str(pool_size) + str(pool_type)
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name+text), name]) # 复制图元对象的标签
|
|
|
self.AllModelObj[-1].ParaString.append([pool_type, pool_size])
|
|
|
self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetPollPara(self.AllModelObj[-1]))
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
|
|
|
def fully_connected(self, event):
|
|
|
i, x, y = self.element_adjustment(event, True, '全连接', 3)
|
|
|
|
|
|
FullConn = FullConn_Class("FullConn" + str(i), 4, "全连接" + str(i), [], x, CNN.Yt)
|
|
|
self.AllModelObj.append(FullConn)
|
|
|
top = CNN.creat_window("全连接参数配置")
|
|
|
num_outputs_entry = CNN.create_input_box(top, "全连接输出维度：", 10)
|
|
|
name = '全连接' if i == 1 else '全连接' + str(i)
|
|
|
def get_input():
|
|
|
global Listinstance
|
|
|
# 从下拉框中获取输出维度
|
|
|
num = int(num_outputs_entry.get())
|
|
|
# 复制对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name), name])
|
|
|
self.AllModelObj[-1].ParaString.append(num)
|
|
|
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def nonlinear(self, event):
|
|
|
i, x, y = self.element_adjustment(event, True, '非线性', 4)
|
|
|
|
|
|
Nonline = Nonline_Class("Nonline" + str(i), 5, "非线性函数" + str(i), [], x, CNN.Yt)
|
|
|
self.AllModelObj.append(Nonline)
|
|
|
top = CNN.creat_window('非线性参数配置') # 创建弹出窗口
|
|
|
# 创建一个下拉框，用于选择非线性类型
|
|
|
nonlinear_mode_combobox = CNN.create_dropdown_box(top, "非线性类型", ["Sigmoid", "ReLU", "Tanh"], "Sigmoid") # 创建一个下拉框，用于选择池化类型
|
|
|
name = '非线性' if i == 1 else '非线性' + str(i)
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
global Listinstance
|
|
|
# 从下拉框中获取池化类型
|
|
|
nonlinear_mode = nonlinear_mode_combobox.get()
|
|
|
# 复制对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name), name])
|
|
|
self.AllModelObj[-1].ParaString.append(nonlinear_mode)
|
|
|
self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetNonLPara(self.AllModelObj[-1]))
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def class_ification(self, event):
|
|
|
i, x, y = self.element_adjustment(event, True, '分类', 5)
|
|
|
|
|
|
Classifier = Classifier_Class("Classifier" + str(i), 6, "分类" + str(i), [], x, CNN.Yt)
|
|
|
self.AllModelObj.append(Classifier)
|
|
|
top = CNN.creat_window('分类参数配置') # 创建弹出窗口
|
|
|
# 创建一个下拉框，用于选择非线性类型
|
|
|
class_box_combobox = CNN.create_input_box(top, "阈值：", 0.001) # 创建一个下拉框，用于选择池化类型
|
|
|
name = '输出分类结果' if i == 1 else '输出分类' + str(i) + '结果'
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 从输入框中获取阈值
|
|
|
threshold = float(class_box_combobox.get())
|
|
|
# 复制对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name), name])
|
|
|
self.AllModelObj[-1].ParaString.append(threshold)
|
|
|
self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetClassifyPara(self.AllModelObj[-1]))
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def error_calculation(self, event):
|
|
|
i, x, y = self.element_adjustment(event, False, '误差', 6)
|
|
|
|
|
|
Error = Error_Class("Error" + str(i), 7, "误差计算" + str(i), [], x, y)
|
|
|
self.AllModelObj.append(Error)
|
|
|
name = '误差' if i == 1 else '误差' + str(i)
|
|
|
# 创建弹出窗口
|
|
|
top = CNN.creat_window('误差参数配置')
|
|
|
# 创建一个下拉框，用于选择误差类型
|
|
|
loss_type_combobox = CNN.create_dropdown_box(top, '误差类型', ["CEE", "MSE", "MAE"],"CEE")
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 从下拉框中获取池化类型
|
|
|
loss_type = loss_type_combobox.get()
|
|
|
# 复制对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name), name])
|
|
|
self.AllModelObj[-1].ParaString.append(loss_type)
|
|
|
self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetErrorPara(self.AllModelObj[-1]))
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def adjust_one(self, event):
|
|
|
i, x, y = self.element_adjustment(event, False, '调整1', 7)
|
|
|
|
|
|
AjConv = AjConv_Class("AjConv" + str(i), 8, "卷积调整" + str(i), [], x, y)
|
|
|
self.AllModelObj.append(AjConv)
|
|
|
name = '调整1' if i == 1 else '调整1 ' + str(i)
|
|
|
# 复制图元对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, y + 45, text=name), name])
|
|
|
|
|
|
def adjust_two(self, event):
|
|
|
i, x, y = self.element_adjustment(event, False, '调整2', 8)
|
|
|
|
|
|
AjFullconn = AjFullconn_Class("AjFullconn" + str(i), 9, "全连接调整" + str(i), [], x, y)
|
|
|
self.AllModelObj.append(AjFullconn)
|
|
|
name = '调整2' if i == 1 else '调整2 ' + str(i)
|
|
|
# 复制图元对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, y + 45, text=name), name])
|
|
|
|
|
|
def adjust_three(self, event): # 调整3
|
|
|
print(self.AllModelObj)
|
|
|
i, x, y = self.element_adjustment(event, False, '调整3', 9)
|
|
|
|
|
|
name = '调整3' if i == 1 else '调整3 ' + str(i)
|
|
|
# 复制图元对象的标签
|
|
|
self.Second_Items[1].append([CNN.Viewcanvas.create_text(x, y + 45, text=name), name])
|
|
|
|
|
|
# 此函数将图元从左侧框复制到右侧框，返回同类图元编号与坐标
|
|
|
def element_adjustment(self, event, regular, name, img_index):
|
|
|
'''
|
|
|
Function: element_adjustment Description: This function copies the element from the left box to the right box and returns the number of the same type of element and its coordinates.
|
|
|
Input:
|
|
|
event: the event object
|
|
|
regular: a boolean value indicating whether y is a fixed value
|
|
|
img_index: the index of the image in the list
|
|
|
name: the name of the element
|
|
|
Output:
|
|
|
i: the number of the same type of element
|
|
|
x: the x-coordinate of the new element
|
|
|
y: the y-coordinate of the new element
|
|
|
'''
|
|
|
x = event.x + CNN.Offset_x
|
|
|
# y是否是固定值
|
|
|
if regular:
|
|
|
y = CNN.Yt
|
|
|
else:
|
|
|
y = event.y + CNN.Offset_y
|
|
|
# 复制一个图片，表示调整操作
|
|
|
new_item = CNN.Viewcanvas.create_image(x, y, image=CNN.List_image[img_index])
|
|
|
self.Second_Items[0].append([new_item, name])
|
|
|
# 同类图元编号
|
|
|
i = self.count_string(name) + 1
|
|
|
# 添加图元名称
|
|
|
self.Element.append(name + ' ' + str(i))
|
|
|
# 恢复图元的原位置
|
|
|
event.widget.coords(CNN.Dragged_item, CNN.Original_x, CNN.Original_y)
|
|
|
# 将新图元的id和坐标添加到列表中
|
|
|
self.Items1.append((new_item, x, y))
|
|
|
# 返回同类图元编号,与坐标
|
|
|
return i, x, y
|
|
|
|
|
|
def main_line(self, event, index):
|
|
|
te = ['参数连接线', '主数据连接线']
|
|
|
choose = [2, 1]
|
|
|
print(self.AllModelConn)
|
|
|
if len(self.Element) > 2:
|
|
|
starting, ending = self.closest_coordinate(event)
|
|
|
top = CNN.creat_window(te[index]) # 创建弹出窗口
|
|
|
# 创建一个下拉框，用于选择图源
|
|
|
start_mode_combobox = CNN.create_dropdown_box(top, "起始图元", self.Element, self.Element[starting])
|
|
|
end_mode_combobox = CNN.create_dropdown_box(top, "终点图元", self.Element, self.Element[ending])
|
|
|
def get_input(): # 创建
|
|
|
result1 = start_mode_combobox.get() # 获取输入框的内容
|
|
|
result2 = end_mode_combobox.get()
|
|
|
start = self.Element.index(result1)
|
|
|
end = self.Element.index(result2)
|
|
|
starting = (self.Items1[start][1], self.Items1[start][2])
|
|
|
ending = (self.Items1[end][1], self.Items1[end][2])
|
|
|
self.conn_lines(starting, ending, index)
|
|
|
i = len(self.AllModelConn)
|
|
|
start_name = Net.AllModelObj[start].ObjID
|
|
|
end_name = Net.AllModelObj[end].ObjID
|
|
|
self.AllModelConn.append(ModelConn(1+i, choose[index], start_name, end_name).output())
|
|
|
top.destroy() # 关闭窗口
|
|
|
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
event.widget.coords(CNN.Dragged_item, CNN.Original_x, CNN.Original_y) # 恢复图元的原位置
|
|
|
|
|
|
def closest_coordinate(self, event):
|
|
|
x = event.x + CNN.Offset_x
|
|
|
y = event.y + CNN.Offset_y
|
|
|
given_coord = (x, y)
|
|
|
coords_list = []
|
|
|
for item in self.Items1:
|
|
|
coords_list.append((item[1], item[2]))
|
|
|
# 初始化最小距离和对应的坐标
|
|
|
min_distance1 = float('inf')
|
|
|
min_distance2 = float('inf')
|
|
|
closest_coord1 = None
|
|
|
closest_coord2 = None
|
|
|
# 遍历列表中的坐标，找到最接近的两个坐标
|
|
|
for coord in coords_list:
|
|
|
dist = math.sqrt((given_coord[0] - coord[0]) ** 2 + (given_coord[1] - coord[1]) ** 2)
|
|
|
if dist < min_distance1:
|
|
|
min_distance2 = min_distance1
|
|
|
closest_coord2 = closest_coord1
|
|
|
min_distance1 = dist
|
|
|
closest_coord1 = coord
|
|
|
elif dist < min_distance2:
|
|
|
min_distance2 = dist
|
|
|
closest_coord2 = coord
|
|
|
coord1 = coords_list.index(closest_coord1)
|
|
|
coord2 = coords_list.index(closest_coord2)
|
|
|
return coord1, coord2
|
|
|
# return min(coord1, coord2), max(coord1, coord2)
|
|
|
|
|
|
def count_string(self, sub_string):
|
|
|
"""
|
|
|
计算列表中包含指定子字符串的元素数量。
|
|
|
Parameters:
|
|
|
- sub_string (str): 要查找的子字符串。
|
|
|
Returns:
|
|
|
- int: 包含指定子字符串的元素数量。
|
|
|
"""
|
|
|
count = 0
|
|
|
for string in self.Element:
|
|
|
if sub_string in string:
|
|
|
count += 1
|
|
|
return count
|
|
|
|
|
|
def conn_lines(self, start, end, index):
|
|
|
smooth = [False, True]
|
|
|
width = [2, 4]
|
|
|
if start[0] == end[0]:
|
|
|
CNN.Viewcanvas.create_line(start[0], start[1] + 30, end[0], end[1] - 30, arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=smooth[index], width=width[index])
|
|
|
elif start[1] == end[1]:
|
|
|
CNN.Viewcanvas.create_line(start[0] + 30, start[1], end[0] - 30, end[1], arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=smooth[index], width=width[index])
|
|
|
else:
|
|
|
if abs(start[0] - end[0]) > abs(start[1] - end[1]):
|
|
|
# 创建数据线箭头
|
|
|
CNN.Viewcanvas.create_line(start[0] - 15, start[1], end[0] + 30,end[1], arrow=tk.LAST,
|
|
|
arrowshape=(16, 20, 4), fill='lightblue', smooth=smooth[index],
|
|
|
width=width[index])
|
|
|
else:
|
|
|
# 创建数据线箭头
|
|
|
CNN.Viewcanvas.create_line(start[0], start[1] - 20, end[0] + 30, end[1], arrow=tk.LAST,arrowshape=(16, 20, 4), fill='lightblue', smooth=smooth[index],
|
|
|
width=width[index])
|
|
|
|
|
|
def check_connection(self):
|
|
|
obj_names = ['DataSet', 'Conv', 'Pool', 'FullConn',
|
|
|
'Nonline', 'Classifier', 'Error',
|
|
|
'AjConv', 'AjFullconn']
|
|
|
if len(Net.AllModelConn) == 0:
|
|
|
messagebox.showerror("错误", "请连接图元！")
|
|
|
return
|
|
|
# print(Net.AllModelConn)
|
|
|
for model_conn in Net.AllModelConn:
|
|
|
start_name = re.sub(r'\d+', '', model_conn[2])
|
|
|
end_name = re.sub(r'\d+', '', model_conn[3])
|
|
|
start = obj_names.index(start_name)
|
|
|
end = obj_names.index(end_name)
|
|
|
if self.RIGHT_MODEL[start][end] == 0:
|
|
|
messagebox.showerror("错误", model_conn[2]+'与' + model_conn[3]+"连接不正确，请检查！")
|
|
|
return
|
|
|
messagebox.showinfo("成功", "连接正确，恭喜！")
|
|
|
|
|
|
def connecting_lines(self, obj_x, obj_y, text, text_record, image):
|
|
|
CNN.Viewcanvas.create_image(obj_x, obj_y, image=image) # 创建图元对象
|
|
|
CNN.Viewcanvas.create_text(obj_x + text_record[0], obj_y + text_record[1], text=text, font=("黑体", 14)) # 创建图元对象的标签
|
|
|
|
|
|
def creating_elements(self):
|
|
|
text_record = [(0, -50), (0, 50), (-80, 0)]
|
|
|
# 遍历AllModelObj列表，在窗口左侧创建图元菜单
|
|
|
for obj in self.AllModelObj:
|
|
|
# 并且要根据需求调整每个对象的位置
|
|
|
obj_x = obj.ObjX # 根据对象的id计算x坐标
|
|
|
obj_y = obj.ObjY # 根据对象的id计算y坐标
|
|
|
self.Item_Record.append((obj_x, obj_y))
|
|
|
self.Item_Name.append(obj.ObjID)
|
|
|
# 根据对象的类型，绘制相应的图形
|
|
|
if 'Error' in obj.ObjID:
|
|
|
self.connecting_lines(obj_x, obj_y, obj.ObjLable, text_record[0], CNN.List_image[obj.ObjType - 1])
|
|
|
elif 'Aj' in obj.ObjID:
|
|
|
self.connecting_lines(obj_x, obj_y, obj.ObjLable, text_record[2], CNN.List_image[-1])
|
|
|
else:
|
|
|
self.connecting_lines(obj_x, obj_y, obj.ObjLable, text_record[1], CNN.List_image[obj.ObjType - 1])
|
|
|
|
|
|
def ligature(self): # 连接线
|
|
|
# print(Item_Record)
|
|
|
for conn in self.AllModelConn:
|
|
|
starting = self.Item_Name.index(conn[2])
|
|
|
# print(starting)
|
|
|
ending = self.Item_Name.index(conn[3])
|
|
|
if conn[1] == 1:
|
|
|
# print(Item_Record[starting])
|
|
|
self.conn_lines(self.Item_Record[starting], self.Item_Record[ending], 1)
|
|
|
else:
|
|
|
self.conn_lines(self.Item_Record[starting], self.Item_Record[ending], 0)
|
|
|
def setpara_func(self):
|
|
|
for i in range(len(self.AllModelObj)):
|
|
|
if self.AllModelObj[i].ObjType == 2: # 卷积
|
|
|
self.modify_conv(i)
|
|
|
elif self.AllModelObj[i].ObjType == 3: # 池化层
|
|
|
pass
|
|
|
elif self.AllModelObj[i].ObjType == 4: # 全连接层
|
|
|
pass
|
|
|
elif self.AllModelObj[i].ObjType == 5: # 非线性层
|
|
|
pass
|
|
|
elif self.AllModelObj[i].ObjType == 6: #分类层
|
|
|
pass
|
|
|
elif self.AllModelObj[i].ObjType == 7: # 误差
|
|
|
pass
|
|
|
def query(self, name, i):
|
|
|
letters = ''.join([char for char in name if char.isalpha()])
|
|
|
numbers = ''.join([char for char in name if char.isdigit()])
|
|
|
x, y, z = -1, -1, -1
|
|
|
for j in range(len(self.Second_Items[1])):
|
|
|
if letters in self.Second_Items[1][j][1]:
|
|
|
z = j
|
|
|
CNN.Viewcanvas.delete(self.Second_Items[1][j][0])
|
|
|
break
|
|
|
if z == -1: # 不存在图元
|
|
|
return -1, -1, -1
|
|
|
l = []
|
|
|
for j in range(len(self.Second_Items[0])):
|
|
|
if letters in self.Second_Items[0][j][1]:
|
|
|
l.append(self.Second_Items[0][j][0])
|
|
|
for item in self.Items1:
|
|
|
if item[0] == l[int(numbers)-1]:
|
|
|
x, y = item[1], item[2]
|
|
|
return x, y, z
|
|
|
|
|
|
def modify_conv(self, i):
|
|
|
"""
|
|
|
右框修改卷积图元参数及AllModelObj参数
|
|
|
Parameters: None
|
|
|
Returns: None
|
|
|
"""
|
|
|
top = CNN.creat_window('卷积参数配置') # 创建弹出窗口
|
|
|
kernel_size_entry = CNN.create_input_box(top, "卷积核大小：", 3) # 创建一个输入框，获取卷积核大小
|
|
|
stride_entry = CNN.create_input_box(top, "卷积步长：", 1) # 创建一个输入框，获取卷积步长
|
|
|
name = self.AllModelObj[i].ObjLable
|
|
|
x, y, z= self.query(name, i)
|
|
|
if x == -1:
|
|
|
return
|
|
|
name = name+':'
|
|
|
def get_input(): # 创建
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(kernel_size_entry.get())
|
|
|
result2 = int(stride_entry.get())
|
|
|
text = str(result1) + "*" + str(result1)
|
|
|
self.Second_Items[1][z] = [CNN.Viewcanvas.create_text(x, y + 45, text=name+text), name] # 复制图元对象的标签
|
|
|
self.AllModelObj[i].ParaString[0] = [result1, result2]
|
|
|
self.AllModelObj[i].ParaString[1] = self.AllModelObj[i].SetConvPara(self.AllModelObj[i])
|
|
|
# print(self.AllModelObj[-1].ParaString)
|
|
|
top.destroy() # 关闭窗口
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
# def modify_pooling(self, id):
|
|
|
# i, x, y = self.element_adjustment(event, True, '池化', 2)
|
|
|
#
|
|
|
# Pool = Pool_Class("Pool" + str(i), 3, "池化" + str(i), [], x, CNN.Yt)
|
|
|
# self.AllModelObj.append(Pool)
|
|
|
# # 创建弹出窗口
|
|
|
# top = CNN.creat_window("池化参数配置")
|
|
|
# pool_type_combobox = CNN.create_dropdown_box(top, "池化池类型：", ["max", "avg", "min"], 'max') # 创建一个下拉框，用于选择池化类型
|
|
|
# pool_size_entry = CNN.create_input_box(top, "池化池大小：", 2) # 创建一个输入框，用于输入池大小
|
|
|
# name = '池化:' if i == 1 else '池化' + str(i) + ':'
|
|
|
# # 创建
|
|
|
# def get_input():
|
|
|
# # 从下拉框中获取池化类型
|
|
|
# pool_type = pool_type_combobox.get()
|
|
|
# # 从输入框中获取池大小
|
|
|
# pool_size = int(pool_size_entry.get())
|
|
|
# text = str(pool_size) + "*" + str(pool_size) + str(pool_type)
|
|
|
# self.Second_Items[1].append(CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name+text)) # 复制图元对象的标签
|
|
|
# self.AllModelObj[-1].ParaString.append([pool_type, pool_size])
|
|
|
# self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetPollPara(self.AllModelObj[-1]))
|
|
|
# # 关闭窗口
|
|
|
# top.destroy()
|
|
|
# button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
# button.pack()
|
|
|
#
|
|
|
#
|
|
|
# def modify_fully(self, id):
|
|
|
# i, x, y = self.element_adjustment(event, True, '全连接', 3)
|
|
|
#
|
|
|
# FullConn = FullConn_Class("FullConn" + str(i), 4, "全连接" + str(i), [], x, CNN.Yt)
|
|
|
# self.AllModelObj.append(FullConn)
|
|
|
# top = CNN.creat_window("全连接参数配置")
|
|
|
# num_outputs_entry = CNN.create_input_box(top, "全连接输出维度：", 10)
|
|
|
# name = '全连接' if i == 1 else '全连接' + str(i)
|
|
|
# def get_input():
|
|
|
# global Listinstance
|
|
|
# # 从下拉框中获取输出维度
|
|
|
# num = int(num_outputs_entry.get())
|
|
|
# # 复制对象的标签
|
|
|
# self.Second_Items[1].append(CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name))
|
|
|
# self.AllModelObj[-1].ParaString.append(num)
|
|
|
#
|
|
|
# # 关闭窗口
|
|
|
# top.destroy()
|
|
|
# button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
# button.pack()
|
|
|
#
|
|
|
# def modify_nonlinear(self, id):
|
|
|
# i, x, y = self.element_adjustment(event, True, '非线性', 4)
|
|
|
#
|
|
|
# Nonline = Nonline_Class("Nonline" + str(i), 5, "非线性函数" + str(i), [], x, CNN.Yt)
|
|
|
# self.AllModelObj.append(Nonline)
|
|
|
# top = CNN.creat_window('非线性参数配置') # 创建弹出窗口
|
|
|
# # 创建一个下拉框，用于选择非线性类型
|
|
|
# nonlinear_mode_combobox = CNN.create_dropdown_box(top, "非线性类型", ["Sigmoid", "ReLU", "Tanh"], "Sigmoid") # 创建一个下拉框，用于选择池化类型
|
|
|
# name = '非线性' if i == 1 else '非线性' + str(i)
|
|
|
# # 创建
|
|
|
# def get_input():
|
|
|
# global Listinstance
|
|
|
# # 从下拉框中获取池化类型
|
|
|
# nonlinear_mode = nonlinear_mode_combobox.get()
|
|
|
# # 复制对象的标签
|
|
|
# self.Second_Items[1].append(CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name))
|
|
|
# self.AllModelObj[-1].ParaString.append(nonlinear_mode)
|
|
|
# self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetNonLPara(self.AllModelObj[-1]))
|
|
|
# # 关闭窗口
|
|
|
# top.destroy()
|
|
|
# button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
# button.pack()
|
|
|
#
|
|
|
# def modify_class(self, id):
|
|
|
# i, x, y = self.element_adjustment(event, True, '分类', 5)
|
|
|
#
|
|
|
# Classifier = Classifier_Class("Classifier" + str(i), 6, "分类" + str(i), [], x, CNN.Yt)
|
|
|
# self.AllModelObj.append(Classifier)
|
|
|
# top = CNN.creat_window('分类参数配置') # 创建弹出窗口
|
|
|
# # 创建一个下拉框，用于选择非线性类型
|
|
|
# class_box_combobox = CNN.create_input_box(top, "阈值：", 0.001) # 创建一个下拉框，用于选择池化类型
|
|
|
# name = '输出分类结果' if i == 1 else '输出分类' + str(i) + '结果'
|
|
|
# # 创建
|
|
|
# def get_input():
|
|
|
# # 从输入框中获取阈值
|
|
|
# threshold = float(class_box_combobox.get())
|
|
|
# # 复制对象的标签
|
|
|
# self.Second_Items[1].append(CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name))
|
|
|
# self.AllModelObj[-1].ParaString.append(threshold)
|
|
|
# self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetClassifyPara(self.AllModelObj[-1]))
|
|
|
# # 关闭窗口
|
|
|
# top.destroy()
|
|
|
# button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
# button.pack()
|
|
|
#
|
|
|
# def modify_error(self, id):
|
|
|
# i, x, y = self.element_adjustment(event, False, '误差', 6)
|
|
|
#
|
|
|
# Error = Error_Class("Error" + str(i), 7, "误差计算" + str(i), [], x, y)
|
|
|
# self.AllModelObj.append(Error)
|
|
|
# name = '误差' if i == 1 else '误差' + str(i)
|
|
|
# # 创建弹出窗口
|
|
|
# top = CNN.creat_window('误差参数配置')
|
|
|
# # 创建一个下拉框，用于选择误差类型
|
|
|
# loss_type_combobox = CNN.create_dropdown_box(top, '误差类型', ["CEE", "MSE", "MAE"],"CEE")
|
|
|
# # 创建
|
|
|
# def get_input():
|
|
|
# # 从下拉框中获取池化类型
|
|
|
# loss_type = loss_type_combobox.get()
|
|
|
# # 复制对象的标签
|
|
|
# self.Second_Items[1].append(CNN.Viewcanvas.create_text(x, CNN.Yt + 45, text=name))
|
|
|
# self.AllModelObj[-1].ParaString.append(loss_type)
|
|
|
# self.AllModelObj[-1].ParaString.append(self.AllModelObj[-1].SetErrorPara(self.AllModelObj[-1]))
|
|
|
# # 关闭窗口
|
|
|
# top.destroy()
|
|
|
# button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
# button.pack()
|
|
|
|
|
|
class ModelObj: # 网络对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
self.ObjID = ObjID # 图元号
|
|
|
self.ObjType = ObjType # 图元类别
|
|
|
self.ObjLable = ObjLable # 对象标签
|
|
|
self.ParaString = ParaString # 参数字符串
|
|
|
self.ObjX = ObjX # 对象位置x坐标
|
|
|
self.ObjY = ObjY # 对象位置y坐标
|
|
|
|
|
|
class Data_Class(ModelObj): # 数据集网络对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.LoadData = self.load_data # 基本操作函数
|
|
|
self.SetDataPara = self.set_data_para # 参数设置函数
|
|
|
|
|
|
# 定义加载数据集load_data()
|
|
|
def load_data(self, DataPara):
|
|
|
global SubFolders
|
|
|
listimages = [] # 存储图片的列表
|
|
|
list_path = []
|
|
|
SubFolders, train_Path = read_folders(DataPara["train_imgPath"])
|
|
|
list_path.append(train_Path)
|
|
|
_, path_list = read_folders(DataPara["test_imgPath"])
|
|
|
list_path.append(path_list)
|
|
|
for data_path in list_path:
|
|
|
images = [] # 存储图片的列表
|
|
|
for path in data_path:
|
|
|
# print(path)
|
|
|
img = self.image_to_array(path, DataPara["img_width"], DataPara["img_height"]) # 读取图片数据
|
|
|
img = img.T # 转置，图像的行和列将互换位置。
|
|
|
images.append(img) # 将图片数组添加到训练集图片列表中
|
|
|
listimages.append(np.array(images)) # 返回转换后的数组
|
|
|
return listimages[0], listimages[1]
|
|
|
|
|
|
def set_data_para(self):# 定义加载数据集的参数SetLoadData()
|
|
|
# 设置数据集路径信息
|
|
|
train_imgPath = filedialog.askdirectory(title="请选择训练集") + "/" # 训练集文件夹的位置
|
|
|
test_imgPath = filedialog.askdirectory(title="请选择测试集") + "/" # 测试集文件夹的位置
|
|
|
# 设置图片大小
|
|
|
img_width = 48 # 图片宽度
|
|
|
img_height = 48 # 图片高度
|
|
|
# 设置每批次读入图片的数量
|
|
|
batch_size = 32 # 批次大小
|
|
|
# 返回DataPara参数，这里用一个字典来存储
|
|
|
DataPara = {"train_imgPath": train_imgPath,
|
|
|
"test_imgPath": test_imgPath,
|
|
|
"img_width": img_width,
|
|
|
"img_height": img_height,
|
|
|
"batch_size": batch_size}
|
|
|
return DataPara
|
|
|
|
|
|
def images_statistics(self, folder_path):
|
|
|
# 获取所有子文件夹路径
|
|
|
subfolders = glob.glob(os.path.join(folder_path, '*'))
|
|
|
# 遍历子文件夹并统计照片数量
|
|
|
for subfolder in subfolders:
|
|
|
if os.path.isdir(subfolder):
|
|
|
subfolder_name = os.path.basename(subfolder)
|
|
|
photos = glob.glob(os.path.join(subfolder, '*.jpg')) # 假设照片文件是jpg格式，可根据实际情况修改
|
|
|
print(f'类别 {subfolder_name} 中的照片数量：{len(photos)}')
|
|
|
|
|
|
# 定义一个函数，实现图片转换为数组的功能
|
|
|
def image_to_array(self, path, height, width):
|
|
|
img = Image.open(path).convert("L") # 转换为灰度模式
|
|
|
img = img.resize((height, width)) # 将图片缩放为height*width的固定大小
|
|
|
data = np.array(img) # 将图片转换为数组格式
|
|
|
data = data / 255.0 # 将数组中的数值归一化，除以255
|
|
|
return data
|
|
|
|
|
|
class Conv_Class(ModelObj): # 卷积对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.ConvProc = self.conv_proc # 基本操作函数
|
|
|
self.SetConvPara = self.setconv_para # 参数设置函数
|
|
|
# 定义卷积函数ConvProc()
|
|
|
def conv_proc(self, 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 setconv_para(self, model_obj):# 定义设置卷积参数的函数SetConvPara()
|
|
|
# 从Conv的ParaString得到一个包含所有卷积参数的列表
|
|
|
conv_list = model_obj.ParaString[0]
|
|
|
height, stride = conv_list[0], conv_list[1]
|
|
|
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 = {"kernel": kernel,
|
|
|
"kernel_h": height,
|
|
|
"kernel_w": height,
|
|
|
"stride": stride,
|
|
|
"padding": padding,
|
|
|
"bias": bias}
|
|
|
return ConvPara
|
|
|
|
|
|
class Pool_Class(ModelObj): # 池化对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.PoolProc = self.pool_proc # 基本操作函数
|
|
|
self.SetPollPara = self.setpool_para # 参数设置函数
|
|
|
|
|
|
def pool_proc(self, image, PoolPara):
|
|
|
pool_mode = PoolPara["pool_mode"]
|
|
|
pool_size = PoolPara["pool_size"]
|
|
|
stride = PoolPara["stride"]
|
|
|
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 setpool_para(self, model_obj):
|
|
|
# 从Pool的ParaString得到一个包含所有池化参数的列表
|
|
|
pool_list = model_obj.ParaString[0]
|
|
|
# 池大小和池类型
|
|
|
pool_mode, pool_size = pool_list[0], pool_list[1]
|
|
|
pool_size = int(pool_size)
|
|
|
stride = 2 # 设置步长，这里假设是2
|
|
|
PoolPara = {"pool_mode": pool_mode, # 返回PoolPara参数，这里用一个字典来存储
|
|
|
"pool_size": pool_size,
|
|
|
"stride": stride}
|
|
|
return PoolPara # 返回PoolPara参数
|
|
|
|
|
|
class FullConn_Class(ModelObj): # 全连接对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.FullConnProc = self.fullconn_proc # 基本操作函数
|
|
|
self.SetFullConnPara = self.setfullconn_para # 参数设置函数
|
|
|
|
|
|
def fullconn_proc(self, inputdata, FullConnPara):
|
|
|
weights = FullConnPara["weights"] # 从FullConnPara参数中获取权重矩阵
|
|
|
bias = FullConnPara["bias"] # 偏置向量
|
|
|
inputdata = inputdata.reshape(1, inputdata.shape[1] * inputdata.shape[2]) # 对输入进行展平处理，变换为单通道的一维数组格式
|
|
|
output = np.dot(inputdata, weights.T) + bias # 计算全连接层的线性变换：inputdata与权重矩阵w进行乘法，再加上偏置向量b
|
|
|
return output # 返回全连接计算后的数组
|
|
|
|
|
|
# 定义一个函数来设置全连接层的相关参数，这里可以根据实际情况修改或随机生成
|
|
|
def setfullconn_para(self, data, model_obj):
|
|
|
# 从FullConn的ParaString得到一个包含所有全连接参数的列表
|
|
|
num_outputs = model_obj.ParaString[0]
|
|
|
# 设置权重矩阵及其输出维度
|
|
|
num_outputs = int(num_outputs)
|
|
|
# 获取池化后的图片数组的长度和宽度
|
|
|
dim = len(data.shape)
|
|
|
if dim == 2:
|
|
|
height, width = data.shape
|
|
|
elif dim == 3:
|
|
|
c, height, width = data.shape
|
|
|
num_outputs = num_outputs
|
|
|
weights = np.random.randn(num_outputs, height * width)
|
|
|
bias = np.random.randn(1, num_outputs)
|
|
|
# 返回FullConnPara参数，这里用一个字典来存储
|
|
|
FullConnPara = {"weights": weights, "bias": bias, "num_outputs": num_outputs}
|
|
|
return FullConnPara
|
|
|
|
|
|
class Nonline_Class(ModelObj): # 非线性对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.NonlinearProc = self.nonlinear_proc # 基本操作函数
|
|
|
self.SetNonLPara = self.setnonl_para # 参数设置函数
|
|
|
|
|
|
# 定义非线性函数
|
|
|
def nonlinear_proc(self, 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 setnonl_para(self, model_obj):
|
|
|
# 从Nonline的ParaString得到一个包含所有非线性参数的列表
|
|
|
nonlinearmode = model_obj.ParaString[0]
|
|
|
NonLPara = {"nonlinearmode": nonlinearmode} # 返回NonLPara参数，这里用一个字典来存储
|
|
|
return NonLPara # 返回NonLPara参数
|
|
|
|
|
|
class Label: # 标签
|
|
|
# 设置标签类别列表并将其转化为one-hot向量的形式
|
|
|
def setlabel_para(self, label_list):
|
|
|
num_classes = len(label_list)
|
|
|
identity_matrix = np.eye(num_classes)
|
|
|
label_dict = {label: identity_matrix[i] for i, label in enumerate(label_list)}
|
|
|
return label_dict
|
|
|
# 读取样本数据集，遍历每个样本，并将样本和对应的标签组成元组，返回标记好标签的样本列表
|
|
|
def label_proc(self, samples, labels, label_dict):
|
|
|
labeled_samples = [(sample, label_dict[label]) for sample, label in zip(samples, labels)]
|
|
|
return labeled_samples
|
|
|
def label_array(self, i, batch):
|
|
|
# 读取标签数据
|
|
|
path_csv = Net.ImgPath[0].split('/')[-2] + '.csv'
|
|
|
df = pd.read_csv(path_csv, header=None, skiprows=range(0, i * batch), nrows=(i + 1) * batch - i * batch)
|
|
|
# print(df)
|
|
|
# 将标签数据转化成数组
|
|
|
right_label = df.iloc[:, 0].tolist()
|
|
|
right_label = list(map(int, right_label))
|
|
|
right_label = [x for x in right_label]
|
|
|
# print(right_label)
|
|
|
return right_label
|
|
|
|
|
|
class Classifier_Class(ModelObj): # 分类对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.ClassifierProc = self.classifier_proc # 基本操作函数
|
|
|
self.SetClassifyPara = self.setclassify_para # 参数设置函数
|
|
|
|
|
|
def classifier_proc(self, 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 setclassify_para(self, model_obj):
|
|
|
# 设定阈值,可以根据你的数据和任务来调整阈值
|
|
|
threshold = float(model_obj.ParaString[0])
|
|
|
# 返回ClassifyPara参数，这里用一个字典来存储
|
|
|
ClassifyPara = {"threshold": threshold}
|
|
|
# 返回ClassifyPara参数
|
|
|
return ClassifyPara
|
|
|
|
|
|
class Error_Class(ModelObj): # 误差计算对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.ErrorProc = self.error_proc # 基本操作函数
|
|
|
self.SetErrorPara = self.seterror_para # 参数设置函数
|
|
|
|
|
|
def error_proc(self, input, label, ErrorPara):
|
|
|
label_list, loss_type = ErrorPara # 读取标签列表和损失函数类型
|
|
|
one_hot_matrix = np.eye(len(label_list)) # 创建一个单位矩阵，大小为标签类别的个数
|
|
|
index = [x for x in label]
|
|
|
# print(label)
|
|
|
label_one_hot = np.take(one_hot_matrix, index, axis=0) # 从one-hot矩阵中取出对应的向量
|
|
|
# print(label_one_hot)
|
|
|
if loss_type == "CEE": # 确定损失函数类别，实现不同的损失函数，计算输入值与label之间的误差
|
|
|
# 使用交叉熵损失函数，公式为：-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") # 如果损失函数类型不在以上三种中，抛出异常
|
|
|
return loss # 返回误差值loss
|
|
|
|
|
|
# 定义设置误差参数的函数
|
|
|
def seterror_para(self, model_obj):
|
|
|
label_list = [i for i in range(len(SubFolders))]# 确定参数信息: 标签类别，损失函数类型
|
|
|
# 假设损失函数类型为交叉熵（Cross Entropy Error，CEE）
|
|
|
# 从Error的ParaString得到
|
|
|
loss_type = model_obj.ParaString[0]
|
|
|
# 返回ErrorProc参数，这里用一个元组来存储
|
|
|
ErrorPara = (label_list, loss_type)
|
|
|
# 返回ErrorPara参数
|
|
|
return ErrorPara
|
|
|
|
|
|
class AjConv_Class(ModelObj): # 卷积调整对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.AjConvProc = self.ajconv_proc # 基本操作函数
|
|
|
self.SetAjConvPara = self.setajconv_para # 参数设置函数
|
|
|
|
|
|
def ajconv_proc(self, images, AjConvPara):
|
|
|
kernel_grad_list = []
|
|
|
bias_grad = 0 # 初始化偏置项梯度为零
|
|
|
for c in images:
|
|
|
# 计算卷积核和偏置项的梯度
|
|
|
kernel_grad = np.zeros_like(AjConvPara['kernel_info']) # 初始化卷积核梯度为零矩阵
|
|
|
for i in range(AjConvPara['loss'].shape[0]): # 遍历误差值矩阵的行
|
|
|
for j in range(AjConvPara['loss'].shape[1]): # 遍历误差值矩阵的列
|
|
|
# 将输入数据数组中对应的子矩阵旋转180度，与误差值相乘，累加到卷积核梯度上
|
|
|
kernel_grad += np.rot90(c[i:i + kernel_grad.shape[0], j:j + kernel_grad.shape[0]], 2) * AjConvPara['loss'][i, j]
|
|
|
# 将误差值累加到偏置项梯度上
|
|
|
bias_grad += AjConvPara['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(images) # 沿着第0个维度求和
|
|
|
# 更新卷积核和偏置项参数
|
|
|
kernel = AjConvPara['kernel_info'] - AjConvPara['learning_rate'] * kernel_grad # 卷积核参数减去学习率乘以卷积核梯度
|
|
|
bias = AjConvPara['bias'] - AjConvPara['learning_rate'] * bias_grad # 偏置项参数减去学习率乘以偏置项梯度
|
|
|
return kernel, bias # 返回更新后的卷积参数
|
|
|
|
|
|
def setajconv_para(self, loss, ConvPara):
|
|
|
# print(model_obj)
|
|
|
# ConvPara = model_obj.ParaString[1]
|
|
|
kernel = ConvPara['kernel'] # 卷积核信息
|
|
|
bias = 0.5
|
|
|
learning_rate = 0.01 # 学习率
|
|
|
loss = np.array([[loss]])
|
|
|
AjConvPara = {'kernel_info': kernel, 'bias': bias, 'learning_rate': learning_rate, 'loss': loss}
|
|
|
return AjConvPara
|
|
|
|
|
|
class AjFullconn_Class(ModelObj): # 全连接调整对象
|
|
|
def __init__(self, ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY):
|
|
|
super().__init__(ObjID, ObjType, ObjLable, ParaString, ObjX, ObjY)
|
|
|
self.AjFullconnProc = self.ajfullconn_proc # 基本操作函数
|
|
|
self.SetAjFCPara = self.setajfc_para # 参数设置函数
|
|
|
|
|
|
def ajfullconn_proc(self, AjFCPara):
|
|
|
# 根据激活函数的参数选择相应的函数和导数
|
|
|
# 计算权重矩阵和偏置向量的梯度，使用链式法则
|
|
|
gradient_weights = np.outer(AjFCPara['loss'], AjFCPara['learning_rate'])
|
|
|
# 更新权重矩阵和偏置向量
|
|
|
weight_matrix = AjFCPara['weights'] - gradient_weights
|
|
|
bias_vector = AjFCPara['bias'] - AjFCPara['learning_rate'] * AjFCPara['bias']
|
|
|
# 返回更新后的权重矩阵和偏置向量
|
|
|
return weight_matrix, bias_vector
|
|
|
|
|
|
def setajfc_para(self, loss, FullConnPara):
|
|
|
# FullConnPara = model_obj.ParaString[1]
|
|
|
weights = FullConnPara["weights"]
|
|
|
bias = FullConnPara["bias"]
|
|
|
loss = np.array([loss])
|
|
|
AjFCPara = {
|
|
|
'weights': weights, # 全连接权重
|
|
|
'bias': bias, # 全连接偏置
|
|
|
'learning_rate': 0.01, # 学习率
|
|
|
'loss': loss # 误差值
|
|
|
}
|
|
|
return AjFCPara
|
|
|
|
|
|
|
|
|
class Model:
|
|
|
def __init__(self):
|
|
|
self.Batch_First = [] # 每个批次第一张数据
|
|
|
self.Batch_First_Sheet = [] # 批次第一张数据
|
|
|
self.Flage = 0 # 是否存在模型
|
|
|
self.Train_list = [] # 存储训练设置参数
|
|
|
self.Prob_images = [] # 存储分类的数据
|
|
|
# def button_link(self):
|
|
|
# # 替每个主界面的按钮绑定各自的函数
|
|
|
# CNN.button['button1'].config(command=self.load_model) # 加载已有模型
|
|
|
# CNN.button['button2'].config(command=CNN.restart_new_model) # 新建模型
|
|
|
# CNN.button['button3'].config(command=Net.setpara_func) # 图元参数设置
|
|
|
# CNN.button['button4'].config(command=self.save_model) # 保存模型
|
|
|
# CNN.button['button5'].config(command=Net.check_connection) # 模型正确性检查
|
|
|
# CNN.button['button6'].config(command=CNN.close_program) # 退出
|
|
|
# CNN.button['button7'].config(command=self.train_setting) # 训练参数
|
|
|
# CNN.button['button8'].config(command=self.train) # 训练
|
|
|
|
|
|
def train_setting(self):
|
|
|
top = CNN.creat_window("训练参数配置") # 创建弹出的参数配置窗口
|
|
|
epoch_entry = CNN.create_input_box(top, "训练轮数：", 4) # 创建一个输入框，获取训练轮数
|
|
|
rate_entry = CNN.create_input_box(top, '学习率：', 0.1) # 创建一个输入框，获取学习率
|
|
|
batch_size_entry = CNN.create_input_box(top, "批次：", 32) # 创建一个输入框，获取批次
|
|
|
# 创建
|
|
|
def get_input():
|
|
|
# 获取输入框的内容
|
|
|
result1 = int(epoch_entry.get())
|
|
|
result2 = float(rate_entry.get())
|
|
|
result3 = int(batch_size_entry.get())
|
|
|
self.Train_list.append(result1)
|
|
|
self.Train_list.append(result2)
|
|
|
self.Train_list.append(result3)
|
|
|
# 关闭窗口
|
|
|
top.destroy()
|
|
|
button = tk.Button(top, text="获取信息", command=get_input)
|
|
|
button.pack()
|
|
|
|
|
|
def determine(self):
|
|
|
if len(self.Train_list) == 0:
|
|
|
messagebox.showerror("错误", "请设置训练参数！")
|
|
|
return 0
|
|
|
if len(Net.AllModelObj) == 0:
|
|
|
messagebox.showerror("错误", "请先建立网络！")
|
|
|
return 0
|
|
|
return 1
|
|
|
|
|
|
def train(self): # 训练
|
|
|
if self.determine() == 0:
|
|
|
return
|
|
|
epoch, rate, batch_size = self.Train_list
|
|
|
first_epoch = 1
|
|
|
LabelPara = Label()
|
|
|
count = 0
|
|
|
# 查询误差对象位置
|
|
|
for modelobj in Net.AllModelObj:
|
|
|
# 如果是误差层，结束
|
|
|
if modelobj.ObjType == 7:
|
|
|
break
|
|
|
count += 1
|
|
|
ErrorPara = Net.AllModelObj[count].ParaString[1]
|
|
|
while first_epoch <= epoch:
|
|
|
first_epoch = first_epoch + 1
|
|
|
for i in range(len(Net.Train_images) // batch_size):
|
|
|
images = Net.Train_images[i * batch_size:(i + 1) * batch_size]
|
|
|
self.forward_propagation(images) # 前向传播
|
|
|
prob_images = np.squeeze(self.Prob_images) # 获取分类结果的概率向量数组
|
|
|
batch = len(prob_images)
|
|
|
right_label = LabelPara.label_array(i, batch) # 读取标签数据,将标签数据转化成数组
|
|
|
loss = Net.AllModelObj[count].ErrorProc(prob_images, right_label, ErrorPara) * 0.1 # 计算误差值
|
|
|
print("当前epoch:", first_epoch, i * batch_size, ":", (i + 1) * batch_size, "误差值：", loss)
|
|
|
print("")
|
|
|
self.back_propagation(loss, images) # 反向传播
|
|
|
self.Flage = 1
|
|
|
# 删除指定目录下的所有文件
|
|
|
self.delete_all_files("test_category/")
|
|
|
# 遍历训练图像数据集
|
|
|
for i in range(len(Net.Train_images) // batch_size):
|
|
|
# 从训练图像数据集中获取当前批次的图像
|
|
|
images = Net.Train_images[i * batch_size:(i + 1) * batch_size]
|
|
|
# 进行前向传播，获取图像结果
|
|
|
image_results = self.forward_propagation(images)
|
|
|
# 打印图像结果
|
|
|
print(image_results)
|
|
|
# 遍历每个图像结果
|
|
|
for j in range(len(image_results)):
|
|
|
# 将图像保存到指定目录的子文件夹中
|
|
|
self.save_images_to_folders("test_category/", SubFolders[int(image_results[j]) - 1], images[j])
|
|
|
|
|
|
def delete_all_files(self, folder_path):
|
|
|
# 遍历文件夹中的所有子文件和子文件夹
|
|
|
for root, dirs, files in os.walk(folder_path, topdown=False):
|
|
|
for file_name in files:
|
|
|
file_path = os.path.join(root, file_name)
|
|
|
os.remove(file_path) # 删除文件
|
|
|
for dir_name in dirs:
|
|
|
dir_path = os.path.join(root, dir_name)
|
|
|
shutil.rmtree(dir_path) # 递归删除文件夹
|
|
|
|
|
|
def save_images_to_folders(self, folder_path, number, image_data):
|
|
|
sub_folder_path = os.path.join(folder_path, number)
|
|
|
# 检查数字子文件夹是否存在，若不存在则创建
|
|
|
if not os.path.exists(sub_folder_path):
|
|
|
os.makedirs(sub_folder_path)
|
|
|
# 创建并保存图像到相应的子文件夹中
|
|
|
image = Image.fromarray((image_data * 255).astype(np.uint8))
|
|
|
# 顺时针旋转90度
|
|
|
rotated_image = image.rotate(-90)
|
|
|
# 获取数字子文件夹中已有的照片数量
|
|
|
existing_images = os.listdir(sub_folder_path)
|
|
|
image_count = len(existing_images)
|
|
|
image_path = os.path.join(sub_folder_path, str(image_count + 1) + ".jpg")
|
|
|
rotated_image.save(image_path)
|
|
|
# 前向传播
|
|
|
def forward_propagation(self, images):
|
|
|
outputs = images # 存储每一层的输出结果的列表
|
|
|
data_flow = self.flow() # 网络数据流列表
|
|
|
for modelobj in Net.AllModelObj:
|
|
|
# 如果是卷积层，就调用ConvProc函数，根据卷积核和步长进行卷积计算，并更新输出结果
|
|
|
if modelobj.ObjType == 2:
|
|
|
outputs = self.conn_forward(modelobj, outputs)
|
|
|
# 如果是池化层，就调用PoolProc函数，进行池化计算，并更新输出结果
|
|
|
elif modelobj.ObjType == 3:
|
|
|
outputs = self.pool_forward(modelobj, outputs)
|
|
|
# 如果是全连接层，就调用FullConnProc函数，根据权重矩阵和偏置向量进行全连接计算，并更新输出结果
|
|
|
elif modelobj.ObjType == 4:
|
|
|
outputs = self.fullconn_forward(modelobj, outputs)
|
|
|
# 如果是非线性层，就调用NonlinearProc函数，根据激活函数进行非线性变换，并更新输出结果
|
|
|
elif modelobj.ObjType == 5:
|
|
|
outputs = self.nonlinear_forward(modelobj, outputs)
|
|
|
# 如果是分类层，就调用ClassifierProc函数，根据权重矩阵和偏置向量进行分类计算，并更新输出结果
|
|
|
elif modelobj.ObjType == 6:
|
|
|
outputs = self.classifier_forward(modelobj, outputs)
|
|
|
outputs = np.array(outputs) # 将输出结果列表转换为数组形式，方便后续处理
|
|
|
return outputs # 返回输出结果数组
|
|
|
# 这里是需要连线才使用
|
|
|
# 前向传播
|
|
|
# def forward_propagation(self, images):
|
|
|
# outputs = images # 存储每一层的输出结果的列表
|
|
|
# data_flow = self.flow() # 网络数据流列表
|
|
|
# for model_conn in data_flow:
|
|
|
# obj_count = self.query_obj(model_conn)
|
|
|
# modelobj = Net.AllModelObj[obj_count]
|
|
|
# # 如果是卷积层，就调用ConvProc函数，根据卷积核和步长进行卷积计算，并更新输出结果
|
|
|
# if modelobj.ObjType == 2:
|
|
|
# outputs = self.conn_forward(modelobj, outputs)
|
|
|
# # 如果是池化层，就调用PoolProc函数，进行池化计算，并更新输出结果
|
|
|
# elif modelobj.ObjType == 3:
|
|
|
# outputs = self.pool_forward(modelobj, outputs)
|
|
|
# # 如果是全连接层，就调用FullConnProc函数，根据权重矩阵和偏置向量进行全连接计算，并更新输出结果
|
|
|
# elif modelobj.ObjType == 4:
|
|
|
# outputs = self.fullconn_forward(modelobj, outputs)
|
|
|
# # 如果是非线性层，就调用NonlinearProc函数，根据激活函数进行非线性变换，并更新输出结果
|
|
|
# elif modelobj.ObjType == 5:
|
|
|
# outputs = self.nonlinear_forward(modelobj, outputs)
|
|
|
# # 如果是分类层，就调用ClassifierProc函数，根据权重矩阵和偏置向量进行分类计算，并更新输出结果
|
|
|
# elif modelobj.ObjType == 6:
|
|
|
# outputs = self.classifier_forward(modelobj, outputs)
|
|
|
#
|
|
|
# outputs = np.array(outputs) # 将输出结果列表转换为数组形式，方便后续处理
|
|
|
# return outputs # 返回输出结果数组
|
|
|
|
|
|
def flow(self):
|
|
|
"""
|
|
|
构建网络数据流列表。
|
|
|
Returns:
|
|
|
- list: 包含网络数据流的列表。
|
|
|
"""
|
|
|
data_flow = [] # 网络数据流列表
|
|
|
# 定义可能出现在数据流中的前向模块名称
|
|
|
forward_name = ['Conv', 'Pool', 'FullConn', 'Nonline', 'Classifier']
|
|
|
# 遍历所有模型连接
|
|
|
for model_conn in Net.AllModelConn:
|
|
|
start_data = re.sub(r'\d+', '', model_conn[2]) # 获取连接的起始模型名称（去除数字部分）
|
|
|
# 如果起始数据是 'DataSet'，将连接的目标数据添加到数据流中
|
|
|
if start_data == 'DataSet':
|
|
|
data_flow.append(model_conn[3])
|
|
|
# 如果起始数据是前向模块名称之一
|
|
|
if start_data in forward_name:
|
|
|
# 如果数据流的最后一个元素与连接的起始模型名称相同，将连接的目标数据添加到数据流中
|
|
|
if data_flow[-1] == model_conn[2]:
|
|
|
data_flow.append(model_conn[3])
|
|
|
return data_flow
|
|
|
|
|
|
def query_obj(self, conn_name):
|
|
|
count = -1
|
|
|
for model_obj in Net.AllModelObj:
|
|
|
count += 1
|
|
|
if model_obj.ObjID == conn_name:
|
|
|
break
|
|
|
return count
|
|
|
|
|
|
def conn_forward(self, modelobj, outputs):
|
|
|
ConvPara = modelobj.ParaString[1]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对每一张图片进行前向传播
|
|
|
i = 0
|
|
|
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 = modelobj.ConvProc(output, ConvPara)
|
|
|
new_outputs.append(output)
|
|
|
if i == 0:
|
|
|
i += 1
|
|
|
self.Batch_First.append(output)
|
|
|
# 若为三维矩阵，则保持不变直接卷积处理
|
|
|
elif dim == 3:
|
|
|
output = modelobj.ConvProc(output, ConvPara)
|
|
|
new_outputs.append(output)
|
|
|
if i == 0:
|
|
|
i += 1
|
|
|
self.Batch_First.append(output)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("卷积处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
def pool_forward(self, modelobj, outputs):
|
|
|
PoolPara = modelobj.ParaString[1]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对outputs列表中的每个元素调用PoolProc函数，并将结果添加到new_outputs列表中
|
|
|
i = 0
|
|
|
for output in outputs:
|
|
|
output = modelobj.PoolProc(output, PoolPara)
|
|
|
new_outputs.append(output)
|
|
|
if i == 0:
|
|
|
i += 1
|
|
|
self.Batch_First.append(output)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
print("池化处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
def fullconn_forward(self, modelobj, outputs):
|
|
|
# 判断FullConn全连接是否存在参数
|
|
|
if len(modelobj.ParaString) < 2:
|
|
|
FullConnPara = modelobj.SetFullConnPara(outputs[0], modelobj)
|
|
|
no = self.query_obj(modelobj.ObjID)
|
|
|
Net.AllModelObj[no].ParaString.append(FullConnPara)
|
|
|
else:
|
|
|
FullConnPara = modelobj.ParaString[1]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
i = 0
|
|
|
# 对outputs列表中的每个元素调用FullConnProc函数，并将结果添加到new_outputs列表中
|
|
|
for output in outputs:
|
|
|
output = modelobj.FullConnProc(output, FullConnPara)
|
|
|
new_outputs.append(output)
|
|
|
if i == 0:
|
|
|
i += 1
|
|
|
self.Batch_First.append(output)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("全连接处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
def nonlinear_forward(self, modelobj, outputs):
|
|
|
# 调用设置非线性参数的函数，获取非线性参数
|
|
|
NonLPara = modelobj.ParaString[1]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
# 对outputs列表中的每个元素调用NonlinearProc函数，并将结果添加到new_outputs列表中
|
|
|
i = 0
|
|
|
for output in outputs:
|
|
|
output, output_derivative = modelobj.NonlinearProc(output, NonLPara)
|
|
|
new_outputs.append(output)
|
|
|
if i == 0:
|
|
|
i += 1
|
|
|
self.Batch_First.append(output)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("非线性处理结果：")
|
|
|
print(outputs[0])
|
|
|
print("")
|
|
|
return outputs
|
|
|
|
|
|
def classifier_forward(self, modelobj, outputs):
|
|
|
# 设置分类函数参数
|
|
|
ClassifyPara = modelobj.ParaString[1]
|
|
|
# 初始化一个空列表来存储池化后的结果
|
|
|
new_outputs = []
|
|
|
self.Prob_images = []
|
|
|
|
|
|
# 定义softmax函数
|
|
|
def softmax(x):
|
|
|
# 减去最大值，防止数值溢出
|
|
|
x -= np.max(x)
|
|
|
# 计算指数和归一化
|
|
|
return np.exp(x) / np.sum(np.exp(x))
|
|
|
|
|
|
# 对outputs列表中的每个元素调用ClassifierProc函数，并将结果添加到new_outputs列表中
|
|
|
i = 0
|
|
|
for output in outputs:
|
|
|
outputx = modelobj.ClassifierProc(output, ClassifyPara)
|
|
|
new_outputs.append(outputx)
|
|
|
# 调用softmax函数，得到概率分布向量
|
|
|
prob = softmax(output)
|
|
|
# 将概率向量结果存储到列表
|
|
|
self.Prob_images.append(prob)
|
|
|
if i == 0:
|
|
|
i += 1
|
|
|
self.Batch_First.append(outputx)
|
|
|
# 将new_outputs赋值给outputs
|
|
|
outputs = new_outputs
|
|
|
# 只打印第一张图片信息，检查是否正确计算
|
|
|
print("输出示例概率向量：")
|
|
|
print(self.Prob_images[0:3])
|
|
|
print("")
|
|
|
return outputs
|
|
|
|
|
|
def back_propagation(self, loss, images):
|
|
|
for modelobj in Net.AllModelObj:
|
|
|
if modelobj.ObjType == 8:
|
|
|
self.conv_propagation('Conv1', loss, images)
|
|
|
if modelobj.ObjType == 9:
|
|
|
self.full_propagation('FullConn1', loss)
|
|
|
# 这里是需要连线才使用
|
|
|
# def back_propagation(self, loss, images):
|
|
|
# data_back = [] # 网络反向传播列表
|
|
|
# for model_conn in Net.data_flow:
|
|
|
# forword_name = ['AjConv', 'AjFullconn']
|
|
|
# start_data = re.sub(r'\d+', '', model_conn[2])
|
|
|
# if start_data == 'Error':
|
|
|
# data_back.append([model_conn[3]])
|
|
|
# if start_data in forword_name:
|
|
|
# for i in range(len(data_back)):
|
|
|
# if data_back[i][-1] == model_conn[2]:
|
|
|
# data_back[i].append(model_conn[3])
|
|
|
# for i in data_back:
|
|
|
# if 'AjConv' in i[0]:
|
|
|
# self.conv_propagation(i[1], loss, images)
|
|
|
# if 'AjFullconn' in i[0]:
|
|
|
# self.full_propagation(i[1], loss)
|
|
|
def conv_propagation(self, conv_name, loss, images):
|
|
|
positioning = 0
|
|
|
for i in range(len(Net.AllModelObj)):
|
|
|
if Net.AllModelObj[i].ObjID == conv_name:
|
|
|
positioning = i
|
|
|
if Net.AllModelObj[i].ObjType == 8:
|
|
|
modelobj = Net.AllModelObj[i]
|
|
|
ConvPara = Net.AllModelObj[positioning].ParaString[1]
|
|
|
AjConvPara = modelobj.SetAjConvPara(loss, ConvPara)
|
|
|
kernel, bias = modelobj.AjConvProc(images, AjConvPara)
|
|
|
Net.AllModelObj[positioning].ParaString[1]['kernel'] = kernel
|
|
|
Net.AllModelObj[positioning].ParaString[1]['bias'] = bias
|
|
|
break
|
|
|
|
|
|
def full_propagation(self, full_name, loss):
|
|
|
# 初始化变量 positioning 为 0，用于记录 full_name 在 Net.AllModelObj 中的位置
|
|
|
positioning = 0
|
|
|
# 遍历 Net.AllModelObj 列表
|
|
|
for i in range(len(Net.AllModelObj)):
|
|
|
# 查找 full_name 在 Net.AllModelObj 中的位置
|
|
|
if Net.AllModelObj[i].ObjID == full_name:
|
|
|
positioning = i
|
|
|
if Net.AllModelObj[i].ObjType == 9:
|
|
|
# 获取当前模型对象
|
|
|
modelobj = Net.AllModelObj[i]
|
|
|
# 获取当前模型对象的参数字符串（FullConnPara 是参数的一部分）
|
|
|
FullConnPara = Net.AllModelObj[positioning].ParaString[1]
|
|
|
# 调用 SetAjFCPara 方法设置特定类型模型对象的参数
|
|
|
AjFCPara = modelobj.SetAjFCPara(loss, FullConnPara)
|
|
|
# 调用 AjFullconnProc 方法计算权重和偏置
|
|
|
weight, bias = modelobj.AjFullconnProc(AjFCPara)
|
|
|
# 将计算得到的权重和偏置更新到 Net.AllModelObj 中的相应位置
|
|
|
Net.AllModelObj[positioning].ParaString[1]['weights'] = weight
|
|
|
Net.AllModelObj[positioning].ParaString[1]['bias'] = bias
|
|
|
break
|
|
|
|
|
|
def save_model(self): # 保存网络模型
|
|
|
if len(Net.AllModelConn) == 0:
|
|
|
messagebox.showerror("错误", "请连接图元！")
|
|
|
return
|
|
|
if len(Net.AllModelObj) == 0:
|
|
|
messagebox.showerror("错误", "请添加图元！")
|
|
|
return
|
|
|
if self.Flage==0:
|
|
|
messagebox.showerror("错误", "请先训练模型！")
|
|
|
return
|
|
|
Path = filedialog.askdirectory(title="请选择模型保存") + "/" # 训练集文件夹的位置
|
|
|
file_path = Path + 'AllModelConn.pkl'
|
|
|
# 检查文件是否存在
|
|
|
if os.path.exists(file_path):
|
|
|
# 删除文件
|
|
|
os.remove(file_path)
|
|
|
with open(file_path, "wb") as f:
|
|
|
pickle.dump(Net.AllModelConn, f) # 保存模型
|
|
|
file_path = Path + 'AllModelObj.pkl'
|
|
|
# 检查文件是否存在
|
|
|
if os.path.exists(file_path):
|
|
|
# 删除文件
|
|
|
os.remove(file_path)
|
|
|
with open(file_path, "wb") as f:
|
|
|
pickle.dump(Net.AllModelObj, f) # 保存模型
|
|
|
# # 生成试验数据集，用于保存模型
|
|
|
# test_images = np.random.rand(100, 48, 48) * 0.01
|
|
|
# # 对试验数据集进行前向传播的计算
|
|
|
# print(forward_propagation(test_images))
|
|
|
# # 打开一个本地文件，用w模式或者wb模式
|
|
|
|
|
|
# # 遍历网络结构
|
|
|
# for layer in items3[1:]:
|
|
|
# count_model(layer)
|
|
|
# messagebox.showinfo("成功", "保存正确，恭喜！")
|
|
|
def load_model(self):
|
|
|
# 弹出文件对话框，允许用户选择.pkl文件
|
|
|
file_path1 = filedialog.askopenfilename(filetypes=[("选择网络对象总表", "*.pkl")])
|
|
|
# 判断用户是否选择了文件
|
|
|
if file_path1:
|
|
|
# 读取.pkl文件内容
|
|
|
with open(file_path1, 'rb') as file:
|
|
|
Net.AllModelObj = pickle.load(file)
|
|
|
print(Net.AllModelObj)
|
|
|
# 弹出文件对话框，允许用户选择.pkl文件
|
|
|
file_path2 = filedialog.askopenfilename(filetypes=[("网络连接对象总表", "*.pkl")])
|
|
|
# 判断用户是否选择了文件
|
|
|
if file_path2:
|
|
|
# 读取.pkl文件内容
|
|
|
with open(file_path2, 'rb') as file:
|
|
|
Net.AllModelConn = pickle.load(file)
|
|
|
print(Net.AllModelConn)
|
|
|
Net.creating_elements()
|
|
|
Net.ligature()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
CNN = Interactive_CNN()
|
|
|
Net = Networking()
|
|
|
Mod = Model()
|
|
|
CNN.create_left_element(CNN.List_image)
|
|
|
CNN.button_link()
|
|
|
sys.stdout.write = CNN.redirector
|
|
|
CNN.Root.mainloop()
|
