if __name__ == '__main__': # 数据预处理 d_train, d_test, d_label = data_preprocess() # 计算设备:GPU cuda device = torch.device('cpu') # 超参数 input_size = 1 hidden_size = 20 num_layers = 2 num_classes = 5 batch_size = 10 num_epochs = 130 learning_rate = 0.01 hyper_parameters = (input_size, hidden_size, num_layers, num_classes, num_epochs, learning_rate) # 创建数据加载器，获得按batch大小读入数据的加载器 train_data = MyDataset(d_train, d_label) train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True) test_data = MyDataset(d_test, d_label) test_loader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=False) list_rate = train(device, train_loader, test_loader, *hyper_parameters) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(np.arange(num_epochs)+1, list_rate) plt.xlabel("num_epochs") plt.ylabel("probability") ax.grid() plt.show()

这段代码是用 PyTorch 实现的一个简单的神经网络模型，用于分类任务。主要包括以下几个部分：

1. 数据预处理：包括读取数据集、数据清洗、特征工程等。

2. 定义超参数：包括输入大小、隐藏层大小、隐藏层数量、输出类别数量、批次大小、迭代次数、学习率等。

3. 创建数据加载器：使用 PyTorch 的 DataLoader 类，将训练数据和测试数据划分成批次，方便进行训练和测试。

4. 模型训练：使用定义好的超参数和数据加载器，通过反向传播算法进行模型训练，并将每轮训练的准确率保存到一个列表中。

5. 可视化结果：使用 Matplotlib 库将训练过程中每轮的准确率可视化展示出来。

相关问题

if __name__ == '__main__': # 通过pandas读入数据 data = pd.read_excel('../1data.xls', encoding='utf-8', header=None) data.columns = ['class_label', 'text', 'tokens'] label = data['class_label'] categories = [] for i in label: if i in categories: pass else: categories.append(i) print(categories) le = preprocessing.LabelEncoder().fit_transform(data['class_label']) data["class_label"] = le # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(data["tokens"], data["class_label"], test_size=0.2, random_state=1) # 文本特征提取 X_train_tfidf, tfidf_vectorizer = tfidf(X_train) X_test_tfidf = tfidf_vectorizer.transform(X_test) modelFile = "SVMModel.m" # 训练保存模型 SVMClassify() # 预测测试集结果 SVMTest()

这部分代码是在主函数中进行数据预处理、模型训练和测试的过程。首先，你使用pandas库读取了一个Excel文件，并将数据命名为data。然后，你为数据的列名进行了命名，分别是'class_label'、'text'和'tokens'。

接下来，你提取了标签(label)并将其存储在categories列表中。这个循环遍历了标签(label)列表，如果标签(label)已经在categories列表中，则跳过，否则将其添加到categories列表中。

之后，你使用LabelEncoder对data['class_label']进行了编码，并将编码后的结果存储在le变量中。然后，将data["class_label"]更新为编码后的结果。

接着，你使用train_test_split函数将数据集划分为训练集(X_train, y_train)和测试集(X_test, y_test)，其中测试集占总数据集的20%。

然后，你使用tfidf函数对训练集进行了文本特征提取，得到了训练集的tfidf表示(X_train_tfidf)和tfidf向量化器(tfidf_vectorizer)。

接下来，你指定了模型文件的路径(modelFile)。

然后，你调用了SVMClassify函数进行模型训练，并保存了训练好的模型。

最后，你调用了SVMTest函数对测试集进行预测，并输出了一些评估指标。

def unzip_infer_data(src_path,target_path): ''' 解压预测数据集 ''' if(not os.path.isdir(target_path)): z = zipfile.ZipFile(src_path, 'r') z.extractall(path=target_path) z.close() def load_image(img_path): ''' 预测图片预处理 ''' img = Image.open(img_path) if img.mode != 'RGB': img = img.convert('RGB') img = img.resize((224, 224), Image.BILINEAR) img = np.array(img).astype('float32') img = img.transpose((2, 0, 1)) # HWC to CHW img = img/255 # 像素值归一化 return img infer_src_path = '/home/aistudio/data/data55032/archive_test.zip' infer_dst_path = '/home/aistudio/data/archive_test' unzip_infer_data(infer_src_path,infer_dst_path) para_state_dict = paddle.load("MyCNN") model = MyCNN() model.set_state_dict(para_state_dict) #加载模型参数 model.eval() #验证模式 #展示预测图片 infer_path='data/archive_test/alexandrite_6.jpg' img = Image.open(infer_path) plt.imshow(img) #根据数组绘制图像 plt.show() #显示图像 #对预测图片进行预处理 infer_imgs = [] infer_imgs.append(load_image(infer_path)) infer_imgs = np.array(infer_imgs) label_dic = train_parameters['label_dict'] for i in range(len(infer_imgs)): data = infer_imgs[i] dy_x_data = np.array(data).astype('float32') dy_x_data=dy_x_data[np.newaxis,:, : ,:] img = paddle.to_tensor (dy_x_data) out = model(img) lab = np.argmax(out.numpy()) #argmax():返回最大数的索引 print("第{}个样本,被预测为：{},真实标签为：{}".format(i+1,label_dic[str(lab)],infer_path.split('/')[-1].split("_")[0])) print("结束") 以上代码进行DNN预测，根据这段代码写一段续写一段利用这个模型进行宝石预测的GUI界面,其中包含预测结果是否正确的判断功能

好的，以下是一个简单的GUI界面的代码，可以利用模型进行宝石预测，并且包含预测结果是否正确的判断功能。

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk
import numpy as np
import paddle

class MyCNN(paddle.nn.Layer):
    # 省略模型定义，保持与上述代码一致

def unzip_infer_data(src_path,target_path):
    ''' 解压预测数据集 '''
    if(not os.path.isdir(target_path)):
        z = zipfile.ZipFile(src_path, 'r')
        z.extractall(path=target_path)
        z.close()

def load_image(img_path):
    ''' 预测图片预处理 '''
    img = Image.open(img_path)
    if img.mode != 'RGB':
        img = img.convert('RGB')
    img = img.resize((224, 224), Image.BILINEAR)
    img = np.array(img).astype('float32')
    img = img.transpose((2, 0, 1)) # HWC to CHW
    img = img/255 # 像素值归一化
    return img

def predict(image_path, model):
    label_dic = train_parameters['label_dict']
    data = load_image(image_path)
    dy_x_data = np.array(data).astype('float32')
    dy_x_data = dy_x_data[np.newaxis,:, : ,:]
    img = paddle.to_tensor(dy_x_data)
    out = model(img)
    lab = np.argmax(out.numpy()) #argmax():返回最大数的索引
    return label_dic[str(lab)], label_dic

def check_result(predicted_label, true_label):
    if predicted_label == true_label:
        return True
    else:
        return False

class App:
    def __init__(self, root):
        self.root = root
        self.model = MyCNN()
        para_state_dict = paddle.load("MyCNN")
        self.model.set_state_dict(para_state_dict)
        self.model.eval() #验证模式
        self.label_dic = train_parameters['label_dict']
        self.true_label = ''
        self.predicted_label = ''
        self.result_label = ''

        self.canvas = tk.Canvas(root, width=300, height=300)
        self.canvas.pack(side='left')

        self.frame = tk.Frame(root)
        self.frame.pack(side='right', padx=10)

        self.select_image_button = tk.Button(
            self.frame,
            text='选择图片',
            command=self.select_image)
        self.select_image_button.pack(pady=10)

        self.predict_button = tk.Button(
            self.frame,
            text='预测',
            command=self.predict)
        self.predict_button.pack(pady=10)

        self.result_label = tk.Label(self.frame, text='')
        self.result_label.pack(pady=10)

    def select_image(self):
        file_path = filedialog.askopenfilename()
        if file_path:
            self.image_path = file_path
            self.show_image()

    def show_image(self):
        image = Image.open(self.image_path)
        image = image.resize((300, 300))
        self.photo = ImageTk.PhotoImage(image)
        self.canvas.create_image(0, 0, anchor='nw', image=self.photo)

    def predict(self):
        if hasattr(self, 'image_path'):
            self.true_label = self.image_path.split('/')[-1].split("_")[0]
            self.predicted_label, label_dic = predict(self.image_path, self.model)
            result = check_result(self.predicted_label, self.true_label)
            if result:
                self.result_label.config(text='预测结果正确')
            else:
                self.result_label.config(text='预测结果错误')

if __name__ == '__main__':
    infer_src_path = '/home/aistudio/data/data55032/archive_test.zip'
    infer_dst_path = '/home/aistudio/data/archive_test'
    unzip_infer_data(infer_src_path, infer_dst_path)
    train_parameters = {'label_dict': {'0': 'alexandrite', '1': 'aquamarine', '2': 'diamond', '3': 'emerald', '4': 'opal', '5': 'pearl', '6': 'peridot', '7': 'ruby', '8': 'sapphire', '9': 'spinel', '10': 'tanzanite', '11': 'topaz', '12': 'tourmaline', '13': 'tsavorite'}}

    root = tk.Tk()
    app = App(root)
    root.mainloop()

你可以把以上代码保存为.py文件，在命令行中运行即可看到GUI界面。界面包含一个选择图片的按钮和一个预测按钮。选择图片后，点击预测按钮可以进行宝石预测，并且会显示预测结果是否正确。