diff --git a/Modify.ipynb b/Modify.ipynb
index 4f9c612..6ddedca 100644
--- a/Modify.ipynb
+++ b/Modify.ipynb
@@ -3,691 +3,921 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.323528Z",
-     "start_time": "2025-06-24T17:37:28.321407Z"
-    }
-   },
-   "cell_type": "code",
-   "source": "# Modify.py\n",
-   "id": "98da35e8f6af6b7a",
-   "outputs": [],
-   "execution_count": 9
-  },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.355899Z",
-     "start_time": "2025-06-24T17:37:28.352650Z"
+     "end_time": "2025-06-25T06:49:47.268865Z",
+     "start_time": "2025-06-25T06:49:25.453526Z"
     }
    },
    "cell_type": "code",
    "source": [
+    "# 首先我们导入所有需要的包：\n",
     "import os\n",
     "import random\n",
     "\n",
     "import numpy as np\n",
     "import pandas as pd\n",
-    "import deepquantum as dq\n",
-    "import matplotlib.pyplot as plt\n",
     "import torch\n",
     "import torch.nn as nn\n",
     "import torch.optim as optim\n",
     "import torchvision.transforms as transforms\n",
-    "from torchvision.datasets import FashionMNIST\n",
     "from tqdm import tqdm\n",
+    "from sklearn.metrics import roc_auc_score\n",
     "from torch.utils.data import DataLoader\n",
-    "from multiprocessing import freeze_support\n"
-   ],
-   "id": "fba02718b5ce470f",
-   "outputs": [],
-   "execution_count": 10
-  },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.376643Z",
-     "start_time": "2025-06-24T17:37:28.373463Z"
-    }
-   },
-   "cell_type": "code",
-   "source": [
+    "from torchvision.datasets import FashionMNIST\n",
+    "import deepquantum as dq\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
     "def seed_torch(seed=1024):\n",
+    "    \"\"\"\n",
+    "    Set random seeds for reproducibility.\n",
+    "\n",
+    "    Args:\n",
+    "        seed (int): Random seed number to use. Default is 1024.\n",
+    "    \"\"\"\n",
+    "\n",
     "    random.seed(seed)\n",
     "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
     "    np.random.seed(seed)\n",
     "    torch.manual_seed(seed)\n",
     "    torch.cuda.manual_seed(seed)\n",
+    "\n",
+    "    # Seed all GPUs with the same seed if using multi-GPU\n",
     "    torch.cuda.manual_seed_all(seed)\n",
-    "    torch.backends.cudnn.benchmark = False\n",
-    "    torch.backends.cudnn.deterministic = True\n"
+    "    torch.backends.cudnn.benchmark = True\n",
+    "    torch.backends.cudnn.deterministic = True\n",
+    "\n",
+    "seed_torch(42)  # 使用更常见的随机种子值"
    ],
-   "id": "e21c1ebc100b5079",
+   "id": "9cf2e2b5d8a6892d",
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:49:47.819194Z",
+     "start_time": "2025-06-25T06:49:47.811528Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "def calculate_score(y_true, y_preds):\n",
+    "    # 将模型预测结果转为概率分布\n",
+    "    preds_prob = torch.softmax(y_preds, dim=1)\n",
+    "    # 获得预测的类别（概率最高的一类）\n",
+    "    preds_class = torch.argmax(preds_prob, dim=1)\n",
+    "    # 计算准确率\n",
+    "    correct = (preds_class == y_true).float()\n",
+    "    accuracy = correct.sum() / len(correct)\n",
+    "    return accuracy.cpu().numpy()\n",
+    "\n",
+    "\n",
+    "def train_model(model, criterion, optimizer, train_loader, valid_loader, num_epochs, device):\n",
+    "    \"\"\"\n",
+    "    训练和验证模型。\n",
+    "\n",
+    "    Args:\n",
+    "        model (torch.nn.Module): 要训练的模型。\n",
+    "        criterion (torch.nn.Module): 损失函数。\n",
+    "        optimizer (torch.optim.Optimizer): 优化器。\n",
+    "        train_loader (torch.utils.data.DataLoader): 训练数据加载器。\n",
+    "        valid_loader (torch.utils.data.DataLoader): 验证数据加载器。\n",
+    "        num_epochs (int): 训练的epoch数。\n",
+    "\n",
+    "    Returns:\n",
+    "        model (torch.nn.Module): 训练后的模型。\n",
+    "    \"\"\"\n",
+    "\n",
+    "    model.train()\n",
+    "    train_loss_list = []\n",
+    "    valid_loss_list = []\n",
+    "    train_acc_list = []\n",
+    "    valid_acc_list = []\n",
+    "\n",
+    "    best_valid_acc = 0.0\n",
+    "    patience = 10  # 早停耐心值\n",
+    "    counter = 0   # 计数器\n",
+    "\n",
+    "    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=10)\n",
+    "\n",
+    "    with tqdm(total=num_epochs) as pbar:\n",
+    "        for epoch in range(num_epochs):\n",
+    "            # 训练阶段\n",
+    "            train_loss = 0.0\n",
+    "            train_acc = 0.0\n",
+    "            for images, labels in train_loader:\n",
+    "                images = images.to(device)\n",
+    "                labels = labels.to(device)\n",
+    "                optimizer.zero_grad()\n",
+    "                outputs = model(images)\n",
+    "                loss = criterion(outputs, labels)\n",
+    "                loss.backward()\n",
+    "                optimizer.step()\n",
+    "                train_loss += loss.item()\n",
+    "                train_acc += calculate_score(labels, outputs)\n",
+    "\n",
+    "            train_loss /= len(train_loader)\n",
+    "            train_acc /= len(train_loader)\n",
+    "\n",
+    "            # 验证阶段\n",
+    "            model.eval()\n",
+    "            valid_loss = 0.0\n",
+    "            valid_acc = 0.0\n",
+    "            with torch.no_grad():\n",
+    "                for images, labels in valid_loader:\n",
+    "                    images = images.to(device)\n",
+    "                    labels = labels.to(device)\n",
+    "                    outputs = model(images)\n",
+    "                    loss = criterion(outputs, labels)\n",
+    "                    valid_loss += loss.item()\n",
+    "                    valid_acc += calculate_score(labels, outputs)\n",
+    "\n",
+    "            valid_loss /= len(valid_loader)\n",
+    "            valid_acc /= len(valid_loader)\n",
+    "\n",
+    "            # 学习率调度器更新\n",
+    "            scheduler.step(valid_acc)\n",
+    "\n",
+    "            # 早停机制\n",
+    "            if valid_acc > best_valid_acc:\n",
+    "                best_valid_acc = valid_acc\n",
+    "                torch.save(model.state_dict(), './data/notebook2/best_model.pt')\n",
+    "                counter = 0\n",
+    "            else:\n",
+    "                counter += 1\n",
+    "\n",
+    "            if counter >= patience:\n",
+    "                print(f'Early stopping at epoch {epoch+1} due to no improvement in validation accuracy.')\n",
+    "                break\n",
+    "\n",
+    "            pbar.set_description(f\"Train loss: {train_loss:.3f}  Valid Acc: {valid_acc:.3f}\")\n",
+    "            pbar.update()\n",
+    "\n",
+    "\n",
+    "            train_loss_list.append(train_loss)\n",
+    "            valid_loss_list.append(valid_loss)\n",
+    "            train_acc_list.append(train_acc)\n",
+    "            valid_acc_list.append(valid_acc)\n",
+    "\n",
+    "    # 加载最佳模型权重\n",
+    "    if os.path.exists('./data/notebook2/best_model.pt'):\n",
+    "        model.load_state_dict(torch.load('./data/notebook2/best_model.pt'))\n",
+    "\n",
+    "    # 修改metrics构建方式，确保各数组长度一致\n",
+    "    metrics = {\n",
+    "        'epoch': list(range(1, len(train_loss_list) + 1)),\n",
+    "        'train_acc': train_acc_list,\n",
+    "        'valid_acc': valid_acc_list,\n",
+    "        'train_loss': train_loss_list,\n",
+    "        'valid_loss': valid_loss_list\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "    return model, metrics\n",
+    "\n",
+    "def test_model(model, test_loader, device):\n",
+    "    model.eval()\n",
+    "    test_acc = 0.0\n",
+    "    with torch.no_grad():\n",
+    "        for images, labels in test_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = model(images)\n",
+    "            test_acc += calculate_score(labels, outputs)\n",
+    "\n",
+    "        test_acc /= len(test_loader)\n",
+    "        print(f'Test Acc: {test_acc:.3f}')\n",
+    "    return test_acc"
+   ],
+   "id": "3a0bcd81cba9b9d4",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:49:47.839016Z",
+     "start_time": "2025-06-25T06:49:47.826008Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# 定义图像变换\n",
+    "trans1 = transforms.Compose([\n",
+    "    transforms.RandomHorizontalFlip(),  # 随机水平翻转\n",
+    "    transforms.RandomRotation(10),     # 随机旋转±10度\n",
+    "    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 颜色调整\n",
+    "    transforms.Resize((18, 18)),       # 调整大小为18x18\n",
+    "    transforms.ToTensor(),           # 转换为张量\n",
+    "    transforms.Normalize((0.5,), (0.5,))  # 归一化到[-1, 1]\n",
+    "])\n",
+    "\n",
+    "trans2 = transforms.Compose([\n",
+    "    transforms.RandomHorizontalFlip(),  # 随机水平翻转\n",
+    "    transforms.RandomRotation(10),     # 随机旋转±10度\n",
+    "    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 颜色调整\n",
+    "    transforms.Resize((16, 16)),       # 调整大小为16x16\n",
+    "    transforms.ToTensor(),           # 转换为张量\n",
+    "    transforms.Normalize((0.5,), (0.5,))  # 归一化到[-1, 1]\n",
+    "])\n",
+    "train_dataset = FashionMNIST(root='./data/notebook2', train=False, transform=trans1,download=True)\n",
+    "test_dataset = FashionMNIST(root='./data/notebook2', train=False, transform=trans1,download=True)\n",
+    "\n",
+    "# 定义训练集和测试集的比例\n",
+    "train_ratio = 0.8  # 训练集比例为80%，验证集比例为20%\n",
+    "valid_ratio = 0.2\n",
+    "total_samples = len(train_dataset)\n",
+    "train_size = int(train_ratio * total_samples)\n",
+    "valid_size = int(valid_ratio * total_samples)\n",
+    "\n",
+    "# 分割训练集和测试集\n",
+    "train_dataset, valid_dataset = torch.utils.data.random_split(train_dataset, [train_size, valid_size])\n",
+    "\n",
+    "# 加载随机抽取的训练数据集\n",
+    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)\n",
+    "valid_loader = DataLoader(valid_dataset, batch_size=64, shuffle=False, drop_last=True)\n",
+    "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, drop_last=True)"
+   ],
+   "id": "7228ef013f3a1fdd",
+   "outputs": [],
+   "execution_count": 3
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:49:47.845266Z",
+     "start_time": "2025-06-25T06:49:47.841750Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "singlegate_list = ['rx', 'ry', 'rz', 's', 't', 'p', 'u3']\n",
+    "doublegate_list = ['rxx', 'ryy', 'rzz', 'swap', 'cnot', 'cp', 'ch', 'cu', 'ct', 'cz']"
+   ],
+   "id": "d9e483c48405660",
+   "outputs": [],
+   "execution_count": 4
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:49:47.895431Z",
+     "start_time": "2025-06-25T06:49:47.889872Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# 随机量子卷积层\n",
+    "class RandomQuantumConvolutionalLayer(nn.Module):\n",
+    "    def __init__(self, nqubit, num_circuits, seed:int=1024):\n",
+    "        super(RandomQuantumConvolutionalLayer, self).__init__()\n",
+    "        random.seed(seed)\n",
+    "        self.nqubit = nqubit\n",
+    "        self.cirs = nn.ModuleList([self.circuit(nqubit) for _ in range(num_circuits)])\n",
+    "\n",
+    "    def circuit(self, nqubit):\n",
+    "        cir = dq.QubitCircuit(nqubit)\n",
+    "        cir.rxlayer(encode=True)  # 对原论文的量子线路结构并无影响，只是做了一个数据编码的操作\n",
+    "        cir.barrier()\n",
+    "        for iter in range(3):\n",
+    "            for i in range(nqubit):\n",
+    "                singlegate = random.choice(singlegate_list)\n",
+    "                getattr(cir, singlegate)(i)\n",
+    "            control_bit, target_bit = random.sample(range(0, nqubit - 1), 2)\n",
+    "            doublegate = random.choice(doublegate_list)\n",
+    "            if doublegate[0] in ['r', 's']:\n",
+    "                getattr(cir, doublegate)([control_bit, target_bit])\n",
+    "            else:\n",
+    "                getattr(cir, doublegate)(control_bit, target_bit)\n",
+    "            cir.barrier()\n",
+    "\n",
+    "        cir.observable(0)\n",
+    "        return cir\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        kernel_size, stride = 2, 2\n",
+    "        # [64, 1, 18, 18] -> [64, 1, 9, 18, 2] -> [64, 1, 9, 9, 2, 2]\n",
+    "        x_unflod = x.unfold(2, kernel_size, stride).unfold(3, kernel_size, stride)\n",
+    "        w = int((x.shape[-1] - kernel_size) / stride + 1)\n",
+    "        x_reshape = x_unflod.reshape(-1, self.nqubit)\n",
+    "\n",
+    "        exps = []\n",
+    "        for cir in self.cirs: # out_channels\n",
+    "            cir(x_reshape)\n",
+    "            exp = cir.expectation()\n",
+    "            exps.append(exp)\n",
+    "\n",
+    "        exps = torch.stack(exps, dim=1)\n",
+    "        exps = exps.reshape(x.shape[0], 3, w, w)\n",
+    "        return exps"
+   ],
+   "id": "f24b62bd70ab89eb",
+   "outputs": [],
+   "execution_count": 5
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:49:48.381594Z",
+     "start_time": "2025-06-25T06:49:47.897435Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "net = RandomQuantumConvolutionalLayer(nqubit=4, num_circuits=3, seed=1024)\n",
+    "net.cirs[0].draw()"
+   ],
+   "id": "f97107a549dee68",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1207.22x367.889 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:49:48.391855Z",
+     "start_time": "2025-06-25T06:49:48.387742Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# 基于随机量子卷积层的混合模型\n",
+    "class RandomQCCNN(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(RandomQCCNN, self).__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "            RandomQuantumConvolutionalLayer(nqubit=4, num_circuits=3, seed=1024),   # num_circuits=3代表我们在quanv1层只用了3个量子卷积核\n",
+    "            nn.BatchNorm2d(3),  # 添加批量归一化\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=2, stride=1),\n",
+    "            nn.Conv2d(3, 6, kernel_size=2, stride=1),\n",
+    "            nn.BatchNorm2d(6),  # 添加批量归一化\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=2, stride=1)\n",
+    "        )\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Linear(6 * 6 * 6, 1024),\n",
+    "            nn.BatchNorm1d(1024),  # 添加批量归一化\n",
+    "            nn.Dropout(0.5),  # 增加dropout比例\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(1024, 10)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        x = x.reshape(x.size(0), -1)\n",
+    "        x = self.fc(x)\n",
+    "        return x"
+   ],
+   "id": "82be55cb39abc20a",
+   "outputs": [],
+   "execution_count": 7
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:54:06.782447Z",
+     "start_time": "2025-06-25T06:49:48.398218Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# 修改RandomQCCNN模型的训练参数\n",
+    "num_epochs = 300\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(device)\n",
+    "seed_torch(42)   # 使用相同的随机种子值\n",
+    "model = RandomQCCNN()\n",
+    "model.to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-5)  # 使用AdamW优化器和适当的权重衰减\n",
+    "optim_model, metrics = train_model(model, criterion, optimizer, train_loader, valid_loader, num_epochs, device)\n",
+    "torch.save(optim_model.state_dict(), './data/notebook2/random_qccnn_weights.pt')   # 保存训练好的模型参数，用于后续的推理或测试\n",
+    "pd.DataFrame(metrics).to_csv('./data/notebook2/random_qccnn_metrics.csv', index='None')   # 保存模型训练过程，用于后续图标展示"
+   ],
+   "id": "2087a1b2f259ad1",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cuda\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train loss: 0.556  Valid Acc: 0.760:  11%|█         | 33/300 [04:18<34:49,  7.83s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Early stopping at epoch 34 due to no improvement in validation accuracy.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 8
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:54:11.647094Z",
+     "start_time": "2025-06-25T06:54:06.811569Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "state_dict = torch.load('./data/notebook2/random_qccnn_weights.pt', map_location=device)\n",
+    "random_qccnn_model = RandomQCCNN()\n",
+    "random_qccnn_model.load_state_dict(state_dict)\n",
+    "random_qccnn_model.to(device)\n",
+    "\n",
+    "test_acc = test_model(random_qccnn_model, test_loader, device)"
+   ],
+   "id": "b19364a05a067c50",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Acc: 0.797\n"
+     ]
+    }
+   ],
+   "execution_count": 9
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:54:11.888135Z",
+     "start_time": "2025-06-25T06:54:11.759275Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "data = pd.read_csv('./data/notebook2/random_qccnn_metrics.csv')\n",
+    "epoch = data['epoch']\n",
+    "train_loss = data['train_loss']\n",
+    "valid_loss = data['valid_loss']\n",
+    "train_acc = data['train_acc']\n",
+    "valid_acc = data['valid_acc']\n",
+    "\n",
+    "# 创建图和Axes对象\n",
+    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n",
+    "\n",
+    "# 绘制训练损失曲线\n",
+    "ax1.plot(epoch, train_loss, label='Train Loss')\n",
+    "ax1.plot(epoch, valid_loss, label='Valid Loss')\n",
+    "ax1.set_title('Training Loss Curve')\n",
+    "ax1.set_xlabel('Epoch')\n",
+    "ax1.set_ylabel('Loss')\n",
+    "ax1.legend()\n",
+    "\n",
+    "# 绘制训练准确率曲线\n",
+    "ax2.plot(epoch, train_acc, label='Train Accuracy')\n",
+    "ax2.plot(epoch, valid_acc, label='Valid Accuracy')\n",
+    "ax2.set_title('Training Accuracy Curve')\n",
+    "ax2.set_xlabel('Epoch')\n",
+    "ax2.set_ylabel('Accuracy')\n",
+    "ax2.legend()\n",
+    "\n",
+    "plt.show()"
+   ],
+   "id": "752fc968a05aed09",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1200x500 with 2 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 10
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T06:54:11.966429Z",
+     "start_time": "2025-06-25T06:54:11.961222Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "class ParameterizedQuantumConvolutionalLayer(nn.Module):\n",
+    "    def __init__(self, nqubit, num_circuits):\n",
+    "        super().__init__()\n",
+    "        self.nqubit = nqubit\n",
+    "        self.cirs = nn.ModuleList([self.circuit(nqubit) for _ in range(num_circuits)])\n",
+    "\n",
+    "    def circuit(self, nqubit):\n",
+    "        cir = dq.QubitCircuit(nqubit)\n",
+    "        cir.rxlayer(encode=True)  #对原论文的量子线路结构并无影响，只是做了一个数据编码的操作\n",
+    "        cir.barrier()\n",
+    "        for iter in range(4): #对应原论文中一个量子卷积线路上的深度为4，可控参数一共16个\n",
+    "            cir.rylayer()\n",
+    "            cir.cnot_ring()\n",
+    "            cir.barrier()\n",
+    "\n",
+    "        cir.observable(0)\n",
+    "        return cir\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        kernel_size, stride = 2, 2\n",
+    "        # [64, 1, 18, 18] -> [64, 1, 9, 18, 2] -> [64, 1, 9, 9, 2, 2]\n",
+    "        x_unflod = x.unfold(2, kernel_size, stride).unfold(3, kernel_size, stride)\n",
+    "        w = int((x.shape[-1] - kernel_size) / stride + 1)\n",
+    "        x_reshape = x_unflod.reshape(-1, self.nqubit)\n",
+    "\n",
+    "        exps = []\n",
+    "        for cir in self.cirs: # out_channels\n",
+    "            cir(x_reshape)\n",
+    "            exp = cir.expectation()\n",
+    "            exps.append(exp)\n",
+    "\n",
+    "        exps = torch.stack(exps, dim=1)\n",
+    "        exps = exps.reshape(x.shape[0], 3, w, w)\n",
+    "        return exps"
+   ],
+   "id": "7694f4aa38f91ef2",
    "outputs": [],
    "execution_count": 11
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.406416Z",
-     "start_time": "2025-06-24T17:37:28.403413Z"
+     "end_time": "2025-06-25T06:54:12.225014Z",
+     "start_time": "2025-06-25T06:54:12.053468Z"
     }
    },
    "cell_type": "code",
    "source": [
-    "def calculate_score(y_true, y_preds):\n",
-    "    preds_prob = torch.softmax(y_preds, dim=1)\n",
-    "    preds_class = torch.argmax(preds_prob, dim=1)\n",
-    "    correct = (preds_class == y_true).float()\n",
-    "    return (correct.sum() / len(correct)).cpu().numpy()\n"
+    "# 此处我们可视化其中一个量子卷积核的线路结构：\n",
+    "net = ParameterizedQuantumConvolutionalLayer(nqubit=4, num_circuits=3)\n",
+    "net.cirs[0].draw()"
+   ],
+   "id": "26eb9fed6938a56b",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 2210.55x785.944 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
    ],
-   "id": "f70cc647d264747",
-   "outputs": [],
    "execution_count": 12
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.439020Z",
-     "start_time": "2025-06-24T17:37:28.433485Z"
+     "end_time": "2025-06-25T06:54:12.305720Z",
+     "start_time": "2025-06-25T06:54:12.301733Z"
     }
    },
    "cell_type": "code",
    "source": [
-    "def train_model(model, criterion, optimizer, scheduler, train_loader, valid_loader, num_epochs, device, save_path):\n",
-    "    model.to(device)\n",
-    "    best_acc = 0.0\n",
-    "    metrics = {'epoch': [], 'train_acc': [], 'valid_acc': [], 'train_loss': [], 'valid_loss': []}\n",
+    "# QCCNN整体网络架构：\n",
+    "class QCCNN(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(QCCNN, self).__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "            ParameterizedQuantumConvolutionalLayer(nqubit=4, num_circuits=3),\n",
+    "            nn.BatchNorm2d(3),  # 添加批量归一化\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=2, stride=1)\n",
+    "        )\n",
     "\n",
-    "    for epoch in range(1, num_epochs + 1):\n",
-    "        # --- 训练阶段 ---\n",
-    "        model.train()\n",
-    "        running_loss, running_acc = 0.0, 0.0\n",
-    "        for imgs, labels in train_loader:\n",
-    "            imgs, labels = imgs.to(device), labels.to(device)\n",
-    "            optimizer.zero_grad()\n",
-    "            outputs = model(imgs)\n",
-    "            loss = criterion(outputs, labels)\n",
-    "            loss.backward()\n",
-    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
-    "            optimizer.step()\n",
-    "            running_loss += loss.item()\n",
-    "            running_acc += calculate_score(labels, outputs)\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Linear(8 * 8 * 3, 128),\n",
+    "            nn.BatchNorm1d(128),  # 添加批量归一化\n",
+    "            nn.Dropout(0.5),  # 增加dropout比例\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(128, 10)\n",
+    "        )\n",
     "\n",
-    "        train_loss = running_loss / len(train_loader)\n",
-    "        train_acc = running_acc / len(train_loader)\n",
-    "        scheduler.step()\n",
-    "\n",
-    "        # --- 验证阶段 ---\n",
-    "        model.eval()\n",
-    "        val_loss, val_acc = 0.0, 0.0\n",
-    "        with torch.no_grad():\n",
-    "            for imgs, labels in valid_loader:\n",
-    "                imgs, labels = imgs.to(device), labels.to(device)\n",
-    "                outputs = model(imgs)\n",
-    "                loss = criterion(outputs, labels)\n",
-    "                val_loss += loss.item()\n",
-    "                val_acc += calculate_score(labels, outputs)\n",
-    "\n",
-    "        valid_loss = val_loss / len(valid_loader)\n",
-    "        valid_acc = val_acc / len(valid_loader)\n",
-    "\n",
-    "        metrics['epoch'].append(epoch)\n",
-    "        metrics['train_loss'].append(train_loss)\n",
-    "        metrics['valid_loss'].append(valid_loss)\n",
-    "        metrics['train_acc'].append(train_acc)\n",
-    "        metrics['valid_acc'].append(valid_acc)\n",
-    "\n",
-    "        tqdm.write(f\"[{save_path}] Epoch {epoch}/{num_epochs}  \"\n",
-    "                   f\"Train Acc: {train_acc:.4f}  Valid Acc: {valid_acc:.4f}\")\n",
-    "\n",
-    "        if valid_acc > best_acc:\n",
-    "            best_acc = valid_acc\n",
-    "            torch.save(model.state_dict(), save_path)\n",
-    "\n",
-    "    return model, metrics\n"
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        x = x.reshape(x.size(0), -1)\n",
+    "        x = self.fc(x)\n",
+    "        return x"
    ],
-   "id": "7cfe89d63ab0e68e",
+   "id": "ae9e76ee6bca6e2f",
    "outputs": [],
    "execution_count": 13
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.467170Z",
-     "start_time": "2025-06-24T17:37:28.463678Z"
+     "end_time": "2025-06-25T07:01:17.413980Z",
+     "start_time": "2025-06-25T06:54:12.401415Z"
     }
    },
    "cell_type": "code",
    "source": [
-    "def test_model(model, test_loader, device):\n",
-    "    model.to(device).eval()\n",
-    "    acc = 0.0\n",
-    "    with torch.no_grad():\n",
-    "        for imgs, labels in test_loader:\n",
-    "            imgs, labels = imgs.to(device), labels.to(device)\n",
-    "            outputs = model(imgs)\n",
-    "            acc += calculate_score(labels, outputs)\n",
-    "    acc /= len(test_loader)\n",
-    "    print(f\"Test Accuracy: {acc:.4f}\")\n",
-    "    return acc\n"
+    "# 修改QCCNN模型的训练参数\n",
+    "num_epochs = 300\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "model = QCCNN()\n",
+    "model.to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-5)  # 使用AdamW优化器和适当的权重衰减\n",
+    "optim_model, metrics = train_model(model, criterion, optimizer, train_loader, valid_loader, num_epochs, device)\n",
+    "torch.save(optim_model.state_dict(), './data/notebook2/qccnn_weights.pt')   # 保存训练好的模型参数，用于后续的推理或测试\n",
+    "pd.DataFrame(metrics).to_csv('./data/notebook2/qccnn_metrics.csv', index='None')   # 保存模型训练过程，用于后续图标展示"
+   ],
+   "id": "81c62294cae7da16",
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train loss: 0.531  Valid Acc: 0.784:  16%|█▌        | 48/300 [07:04<37:11,  8.85s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Early stopping at epoch 49 due to no improvement in validation accuracy.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
    ],
-   "id": "235ac16bd786e65f",
-   "outputs": [],
    "execution_count": 14
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2025-06-24T17:37:28.506986Z",
-     "start_time": "2025-06-24T17:37:28.496003Z"
+     "end_time": "2025-06-25T07:01:22.540624Z",
+     "start_time": "2025-06-25T07:01:17.490806Z"
     }
    },
    "cell_type": "code",
    "source": [
-    "singlegate_list = ['rx','ry','rz','s','t','p','u3']\n",
-    "doublegate_list = ['rxx','ryy','rzz','swap','cnot','cp','ch','cu','ct','cz']\n",
+    "state_dict = torch.load('./data/notebook2/qccnn_weights.pt', map_location=device)\n",
+    "qccnn_model = QCCNN()\n",
+    "qccnn_model.load_state_dict(state_dict)\n",
+    "qccnn_model.to(device)\n",
     "\n",
-    "class RandomQuantumConvolutionalLayer(nn.Module):\n",
-    "    def __init__(self, nqubit, num_circuits, seed=1024):\n",
-    "        super().__init__()\n",
-    "        random.seed(seed)\n",
-    "        self.nqubit = nqubit\n",
-    "        self.cirs = nn.ModuleList([self.circuit(nqubit) for _ in range(num_circuits)])\n",
-    "    def circuit(self, nqubit):\n",
-    "        cir = dq.QubitCircuit(nqubit)\n",
-    "        cir.rxlayer(encode=True); cir.barrier()\n",
-    "        for _ in range(3):\n",
-    "            for i in range(nqubit):\n",
-    "                getattr(cir, random.choice(singlegate_list))(i)\n",
-    "            c,t = random.sample(range(nqubit),2)\n",
-    "            gate = random.choice(doublegate_list)\n",
-    "            if gate[0] in ['r','s']:\n",
-    "                getattr(cir, gate)([c,t])\n",
-    "            else:\n",
-    "                getattr(cir, gate)(c,t)\n",
-    "            cir.barrier()\n",
-    "        cir.observable(0)\n",
-    "        return cir\n",
-    "    def forward(self, x):\n",
-    "        k,s = 2,2\n",
-    "        x_unf = x.unfold(2,k,s).unfold(3,k,s)\n",
-    "        w = (x.shape[-1]-k)//s + 1\n",
-    "        x_r = x_unf.reshape(-1, self.nqubit)\n",
-    "        exps = []\n",
-    "        for cir in self.cirs:\n",
-    "            cir(x_r)\n",
-    "            exps.append(cir.expectation())\n",
-    "        exps = torch.stack(exps,1).reshape(x.size(0), len(self.cirs), w, w)\n",
-    "        return exps\n",
-    "\n",
-    "class RandomQCCNN(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super().__init__()\n",
-    "        self.conv = nn.Sequential(\n",
-    "            RandomQuantumConvolutionalLayer(4,3,seed=1024),\n",
-    "            nn.ReLU(), nn.MaxPool2d(2,1),\n",
-    "            nn.Conv2d(3,6,2,1), nn.ReLU(), nn.MaxPool2d(2,1)\n",
-    "        )\n",
-    "        self.fc = nn.Sequential(\n",
-    "            nn.Linear(6*6*6,1024), nn.Dropout(0.4),\n",
-    "            nn.Linear(1024,10)\n",
-    "        )\n",
-    "    def forward(self,x):\n",
-    "        x = self.conv(x)\n",
-    "        x = x.view(x.size(0),-1)\n",
-    "        return self.fc(x)\n",
-    "\n",
-    "class ParameterizedQuantumConvolutionalLayer(nn.Module):\n",
-    "    def __init__(self,nqubit,num_circuits):\n",
-    "        super().__init__()\n",
-    "        self.nqubit = nqubit\n",
-    "        self.cirs = nn.ModuleList([self.circuit(nqubit) for _ in range(num_circuits)])\n",
-    "    def circuit(self,nqubit):\n",
-    "        cir = dq.QubitCircuit(nqubit)\n",
-    "        cir.rxlayer(encode=True); cir.barrier()\n",
-    "        for _ in range(4):\n",
-    "            cir.rylayer(); cir.cnot_ring(); cir.barrier()\n",
-    "        cir.observable(0)\n",
-    "        return cir\n",
-    "    def forward(self,x):\n",
-    "        k,s = 2,2\n",
-    "        x_unf = x.unfold(2,k,s).unfold(3,k,s)\n",
-    "        w = (x.shape[-1]-k)//s +1\n",
-    "        x_r = x_unf.reshape(-1,self.nqubit)\n",
-    "        exps = []\n",
-    "        for cir in self.cirs:\n",
-    "            cir(x_r); exps.append(cir.expectation())\n",
-    "        exps = torch.stack(exps,1).reshape(x.size(0),len(self.cirs),w,w)\n",
-    "        return exps\n",
-    "\n",
-    "class QCCNN(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super().__init__()\n",
-    "        self.conv = nn.Sequential(\n",
-    "            ParameterizedQuantumConvolutionalLayer(4,3),\n",
-    "            nn.ReLU(), nn.MaxPool2d(2,1)\n",
-    "        )\n",
-    "        self.fc = nn.Sequential(\n",
-    "            nn.Linear(8*8*3,128), nn.Dropout(0.4), nn.ReLU(),\n",
-    "            nn.Linear(128,10)\n",
-    "        )\n",
-    "    def forward(self,x):\n",
-    "        x = self.conv(x); x = x.view(x.size(0),-1)\n",
-    "        return self.fc(x)\n",
-    "\n",
-    "def vgg_block(in_c,out_c,n_convs):\n",
-    "    layers = [nn.Conv2d(in_c,out_c,3,padding=1), nn.ReLU()]\n",
-    "    for _ in range(n_convs-1):\n",
-    "        layers += [nn.Conv2d(out_c,out_c,3,padding=1), nn.ReLU()]\n",
-    "    layers.append(nn.MaxPool2d(2,2))\n",
-    "    return nn.Sequential(*layers)\n",
-    "\n",
-    "VGG = nn.Sequential(\n",
-    "    vgg_block(1,10,3),\n",
-    "    vgg_block(10,16,3),\n",
-    "    nn.Flatten(),\n",
-    "    nn.Linear(16*4*4,120), nn.Sigmoid(),\n",
-    "    nn.Linear(120,84), nn.Sigmoid(),\n",
-    "    nn.Linear(84,10), nn.Softmax(dim=-1)\n",
-    ")\n"
+    "test_acc = test_model(qccnn_model, test_loader, device)"
    ],
-   "id": "c996822b3d5f8305",
-   "outputs": [],
-   "execution_count": 15
-  },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-06-24T18:51:44.622880Z",
-     "start_time": "2025-06-24T17:37:28.529442Z"
-    }
-   },
-   "cell_type": "code",
-   "source": [
-    "if __name__ == '__main__':\n",
-    "    freeze_support()\n",
-    "\n",
-    "    # 数据增广与加载\n",
-    "    train_transform = transforms.Compose([\n",
-    "        transforms.Resize((18, 18)),\n",
-    "        transforms.RandomRotation(15),\n",
-    "        transforms.RandomHorizontalFlip(),\n",
-    "        transforms.RandomVerticalFlip(0.3),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Normalize((0.5,), (0.5,))\n",
-    "    ])\n",
-    "    eval_transform = transforms.Compose([\n",
-    "        transforms.Resize((18, 18)),\n",
-    "        transforms.ToTensor(),\n",
-    "        transforms.Normalize((0.5,), (0.5,))\n",
-    "    ])\n",
-    "\n",
-    "    full_train = FashionMNIST(root='./data/notebook2', train=True, transform=train_transform, download=True)\n",
-    "    test_dataset = FashionMNIST(root='./data/notebook2', train=False, transform=eval_transform, download=True)\n",
-    "    train_size = int(0.8 * len(full_train))\n",
-    "    valid_size = len(full_train) - train_size\n",
-    "    train_ds, valid_ds = torch.utils.data.random_split(full_train, [train_size, valid_size])\n",
-    "    valid_ds.dataset.transform = eval_transform\n",
-    "\n",
-    "    batch_size = 128\n",
-    "    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True,  drop_last=True, num_workers=4)\n",
-    "    valid_loader = DataLoader(valid_ds, batch_size=batch_size, shuffle=False, drop_last=True, num_workers=4)\n",
-    "    test_loader  = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, drop_last=False, num_workers=4)\n",
-    "\n",
-    "    # 三种模型配置\n",
-    "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-    "    models = {\n",
-    "        'random_qccnn': (RandomQCCNN(), 1e-3, './data/notebook2/random_qccnn_best.pt'),\n",
-    "        'qccnn':        (QCCNN(),        1e-4, './data/notebook2/qccnn_best.pt'),\n",
-    "        'vgg':          (VGG,            1e-4, './data/notebook2/vgg_best.pt')\n",
-    "    }\n",
-    "\n",
-    "    all_metrics = {}\n",
-    "    for name, (model, lr, save_path) in models.items():\n",
-    "        seed_torch(1024)\n",
-    "        model = model.to(device)\n",
-    "        criterion = nn.CrossEntropyLoss()\n",
-    "        optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)\n",
-    "        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)\n",
-    "\n",
-    "        print(f\"\\n=== Training {name} ===\")\n",
-    "        _, metrics = train_model(\n",
-    "            model, criterion, optimizer, scheduler,\n",
-    "            train_loader, valid_loader,\n",
-    "            num_epochs=50, device=device, save_path=save_path\n",
-    "        )\n",
-    "        all_metrics[name] = metrics\n",
-    "        pd.DataFrame(metrics).to_csv(f'./data/notebook2/{name}_metrics.csv', index=False)\n",
-    "\n",
-    "    # 测试与可视化\n",
-    "    plt.figure(figsize=(12,5))\n",
-    "    for i,(name,metrics) in enumerate(all_metrics.items(),1):\n",
-    "        model, _, save_path = models[name]\n",
-    "        best_model = model.to(device)\n",
-    "        best_model.load_state_dict(torch.load(save_path))\n",
-    "        print(f\"\\n--- Testing {name} ---\")\n",
-    "        test_model(best_model, test_loader, device)\n",
-    "\n",
-    "        plt.subplot(1,3,i)\n",
-    "        plt.plot(metrics['epoch'], metrics['valid_acc'], label=f'{name} Val Acc')\n",
-    "        plt.xlabel('Epoch'); plt.ylabel('Valid Acc')\n",
-    "        plt.title(name); plt.legend()\n",
-    "\n",
-    "    plt.tight_layout(); plt.show()\n",
-    "\n",
-    "    # 参数量统计\n",
-    "    def count_parameters(m):\n",
-    "        return sum(p.numel() for p in m.parameters() if p.requires_grad)\n",
-    "\n",
-    "    print(\"\\nParameter Counts:\")\n",
-    "    for name,(model,_,_) in models.items():\n",
-    "        print(f\"{name}: {count_parameters(model)}\")\n"
-   ],
-   "id": "2d6b93bb78001086",
+   "id": "ffbeb8b34fdcdbc0",
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\n",
-      "=== Training random_qccnn ===\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 1/50  Train Acc: 0.6377  Valid Acc: 0.7426\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 2/50  Train Acc: 0.7589  Valid Acc: 0.7799\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 3/50  Train Acc: 0.7830  Valid Acc: 0.7955\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 4/50  Train Acc: 0.7928  Valid Acc: 0.8010\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 5/50  Train Acc: 0.7997  Valid Acc: 0.8065\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 6/50  Train Acc: 0.8044  Valid Acc: 0.8140\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 7/50  Train Acc: 0.8097  Valid Acc: 0.8157\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 8/50  Train Acc: 0.8155  Valid Acc: 0.8163\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 9/50  Train Acc: 0.8162  Valid Acc: 0.8159\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 10/50  Train Acc: 0.8169  Valid Acc: 0.8160\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 11/50  Train Acc: 0.8210  Valid Acc: 0.8269\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 12/50  Train Acc: 0.8210  Valid Acc: 0.8266\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 13/50  Train Acc: 0.8241  Valid Acc: 0.8212\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 14/50  Train Acc: 0.8240  Valid Acc: 0.8264\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 15/50  Train Acc: 0.8245  Valid Acc: 0.8231\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 16/50  Train Acc: 0.8270  Valid Acc: 0.8291\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 17/50  Train Acc: 0.8274  Valid Acc: 0.8297\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 18/50  Train Acc: 0.8281  Valid Acc: 0.8338\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 19/50  Train Acc: 0.8295  Valid Acc: 0.8291\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 20/50  Train Acc: 0.8306  Valid Acc: 0.8304\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 21/50  Train Acc: 0.8320  Valid Acc: 0.8280\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 22/50  Train Acc: 0.8316  Valid Acc: 0.8293\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 23/50  Train Acc: 0.8315  Valid Acc: 0.8298\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 24/50  Train Acc: 0.8329  Valid Acc: 0.8282\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 25/50  Train Acc: 0.8321  Valid Acc: 0.8313\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 26/50  Train Acc: 0.8350  Valid Acc: 0.8311\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 27/50  Train Acc: 0.8343  Valid Acc: 0.8335\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 28/50  Train Acc: 0.8347  Valid Acc: 0.8320\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 29/50  Train Acc: 0.8354  Valid Acc: 0.8333\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 30/50  Train Acc: 0.8359  Valid Acc: 0.8314\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 31/50  Train Acc: 0.8380  Valid Acc: 0.8348\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 32/50  Train Acc: 0.8369  Valid Acc: 0.8330\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 33/50  Train Acc: 0.8375  Valid Acc: 0.8367\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 34/50  Train Acc: 0.8373  Valid Acc: 0.8315\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 35/50  Train Acc: 0.8381  Valid Acc: 0.8352\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 36/50  Train Acc: 0.8393  Valid Acc: 0.8374\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 37/50  Train Acc: 0.8384  Valid Acc: 0.8348\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 38/50  Train Acc: 0.8398  Valid Acc: 0.8355\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 39/50  Train Acc: 0.8402  Valid Acc: 0.8365\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 40/50  Train Acc: 0.8400  Valid Acc: 0.8346\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 41/50  Train Acc: 0.8411  Valid Acc: 0.8374\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 42/50  Train Acc: 0.8409  Valid Acc: 0.8373\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 43/50  Train Acc: 0.8415  Valid Acc: 0.8364\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 44/50  Train Acc: 0.8414  Valid Acc: 0.8359\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 45/50  Train Acc: 0.8409  Valid Acc: 0.8364\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 46/50  Train Acc: 0.8419  Valid Acc: 0.8371\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 47/50  Train Acc: 0.8422  Valid Acc: 0.8369\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 48/50  Train Acc: 0.8421  Valid Acc: 0.8360\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 49/50  Train Acc: 0.8417  Valid Acc: 0.8369\n",
-      "[./data/notebook2/random_qccnn_best.pt] Epoch 50/50  Train Acc: 0.8408  Valid Acc: 0.8369\n",
-      "\n",
-      "=== Training qccnn ===\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 1/50  Train Acc: 0.3113  Valid Acc: 0.5076\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 2/50  Train Acc: 0.4621  Valid Acc: 0.5548\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 3/50  Train Acc: 0.5201  Valid Acc: 0.5892\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 4/50  Train Acc: 0.5642  Valid Acc: 0.6311\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 5/50  Train Acc: 0.6056  Valid Acc: 0.6599\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 6/50  Train Acc: 0.6317  Valid Acc: 0.6804\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 7/50  Train Acc: 0.6514  Valid Acc: 0.6929\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 8/50  Train Acc: 0.6678  Valid Acc: 0.7008\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 9/50  Train Acc: 0.6809  Valid Acc: 0.7096\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 10/50  Train Acc: 0.6877  Valid Acc: 0.7186\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 11/50  Train Acc: 0.6976  Valid Acc: 0.7247\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 12/50  Train Acc: 0.7031  Valid Acc: 0.7303\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 13/50  Train Acc: 0.7119  Valid Acc: 0.7317\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 14/50  Train Acc: 0.7164  Valid Acc: 0.7404\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 15/50  Train Acc: 0.7211  Valid Acc: 0.7438\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 16/50  Train Acc: 0.7249  Valid Acc: 0.7481\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 17/50  Train Acc: 0.7294  Valid Acc: 0.7500\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 18/50  Train Acc: 0.7345  Valid Acc: 0.7518\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 19/50  Train Acc: 0.7350  Valid Acc: 0.7550\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 20/50  Train Acc: 0.7391  Valid Acc: 0.7587\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 21/50  Train Acc: 0.7434  Valid Acc: 0.7608\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 22/50  Train Acc: 0.7443  Valid Acc: 0.7634\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 23/50  Train Acc: 0.7481  Valid Acc: 0.7654\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 24/50  Train Acc: 0.7498  Valid Acc: 0.7683\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 25/50  Train Acc: 0.7529  Valid Acc: 0.7696\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 26/50  Train Acc: 0.7547  Valid Acc: 0.7708\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 27/50  Train Acc: 0.7547  Valid Acc: 0.7723\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 28/50  Train Acc: 0.7580  Valid Acc: 0.7736\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 29/50  Train Acc: 0.7571  Valid Acc: 0.7749\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 30/50  Train Acc: 0.7602  Valid Acc: 0.7760\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 31/50  Train Acc: 0.7610  Valid Acc: 0.7767\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 32/50  Train Acc: 0.7618  Valid Acc: 0.7764\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 33/50  Train Acc: 0.7630  Valid Acc: 0.7784\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 34/50  Train Acc: 0.7632  Valid Acc: 0.7791\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 35/50  Train Acc: 0.7627  Valid Acc: 0.7786\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 36/50  Train Acc: 0.7653  Valid Acc: 0.7803\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 37/50  Train Acc: 0.7640  Valid Acc: 0.7811\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 38/50  Train Acc: 0.7674  Valid Acc: 0.7799\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 39/50  Train Acc: 0.7649  Valid Acc: 0.7816\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 40/50  Train Acc: 0.7661  Valid Acc: 0.7823\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 41/50  Train Acc: 0.7668  Valid Acc: 0.7818\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 42/50  Train Acc: 0.7662  Valid Acc: 0.7818\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 43/50  Train Acc: 0.7668  Valid Acc: 0.7824\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 44/50  Train Acc: 0.7678  Valid Acc: 0.7825\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 45/50  Train Acc: 0.7677  Valid Acc: 0.7826\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 46/50  Train Acc: 0.7666  Valid Acc: 0.7827\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 47/50  Train Acc: 0.7689  Valid Acc: 0.7828\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 48/50  Train Acc: 0.7675  Valid Acc: 0.7827\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 49/50  Train Acc: 0.7678  Valid Acc: 0.7828\n",
-      "[./data/notebook2/qccnn_best.pt] Epoch 50/50  Train Acc: 0.7677  Valid Acc: 0.7826\n",
-      "\n",
-      "=== Training vgg ===\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 1/50  Train Acc: 0.2536  Valid Acc: 0.4195\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 2/50  Train Acc: 0.4692  Valid Acc: 0.5073\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 3/50  Train Acc: 0.5270  Valid Acc: 0.5266\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 4/50  Train Acc: 0.5354  Valid Acc: 0.5351\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 5/50  Train Acc: 0.5935  Valid Acc: 0.6175\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 6/50  Train Acc: 0.6366  Valid Acc: 0.6626\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 7/50  Train Acc: 0.6866  Valid Acc: 0.7303\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 8/50  Train Acc: 0.7415  Valid Acc: 0.7512\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 9/50  Train Acc: 0.7542  Valid Acc: 0.7582\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 10/50  Train Acc: 0.7608  Valid Acc: 0.7646\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 11/50  Train Acc: 0.7677  Valid Acc: 0.7719\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 12/50  Train Acc: 0.7705  Valid Acc: 0.7731\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 13/50  Train Acc: 0.7716  Valid Acc: 0.7736\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 14/50  Train Acc: 0.7748  Valid Acc: 0.7749\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 15/50  Train Acc: 0.7763  Valid Acc: 0.7751\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 16/50  Train Acc: 0.7790  Valid Acc: 0.7768\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 17/50  Train Acc: 0.7801  Valid Acc: 0.7802\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 18/50  Train Acc: 0.7818  Valid Acc: 0.7828\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 19/50  Train Acc: 0.7827  Valid Acc: 0.7816\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 20/50  Train Acc: 0.7827  Valid Acc: 0.7840\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 21/50  Train Acc: 0.7849  Valid Acc: 0.7858\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 22/50  Train Acc: 0.7877  Valid Acc: 0.7849\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 23/50  Train Acc: 0.7880  Valid Acc: 0.7849\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 24/50  Train Acc: 0.7891  Valid Acc: 0.7860\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 25/50  Train Acc: 0.7903  Valid Acc: 0.7884\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 26/50  Train Acc: 0.7910  Valid Acc: 0.7900\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 27/50  Train Acc: 0.7919  Valid Acc: 0.7886\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 28/50  Train Acc: 0.7937  Valid Acc: 0.7906\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 29/50  Train Acc: 0.7934  Valid Acc: 0.7876\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 30/50  Train Acc: 0.7946  Valid Acc: 0.7902\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 31/50  Train Acc: 0.7959  Valid Acc: 0.7933\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 32/50  Train Acc: 0.7956  Valid Acc: 0.7933\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 33/50  Train Acc: 0.7971  Valid Acc: 0.7920\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 34/50  Train Acc: 0.7974  Valid Acc: 0.7932\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 35/50  Train Acc: 0.7980  Valid Acc: 0.7948\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 36/50  Train Acc: 0.7985  Valid Acc: 0.7950\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 37/50  Train Acc: 0.7990  Valid Acc: 0.7959\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 38/50  Train Acc: 0.7992  Valid Acc: 0.7949\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 39/50  Train Acc: 0.8001  Valid Acc: 0.7960\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 40/50  Train Acc: 0.8006  Valid Acc: 0.7957\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 41/50  Train Acc: 0.8007  Valid Acc: 0.7963\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 42/50  Train Acc: 0.8015  Valid Acc: 0.7959\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 43/50  Train Acc: 0.8014  Valid Acc: 0.7962\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 44/50  Train Acc: 0.8016  Valid Acc: 0.7965\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 45/50  Train Acc: 0.8018  Valid Acc: 0.7958\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 46/50  Train Acc: 0.8021  Valid Acc: 0.7965\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 47/50  Train Acc: 0.8025  Valid Acc: 0.7966\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 48/50  Train Acc: 0.8026  Valid Acc: 0.7962\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 49/50  Train Acc: 0.8025  Valid Acc: 0.7970\n",
-      "[./data/notebook2/vgg_best.pt] Epoch 50/50  Train Acc: 0.8025  Valid Acc: 0.7970\n",
-      "\n",
-      "--- Testing random_qccnn ---\n",
-      "Test Accuracy: 0.8249\n",
-      "\n",
-      "--- Testing qccnn ---\n",
-      "Test Accuracy: 0.7720\n",
-      "\n",
-      "--- Testing vgg ---\n",
-      "Test Accuracy: 0.7899\n"
+      "Test Acc: 0.797\n"
      ]
-    },
+    }
+   ],
+   "execution_count": 15
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T07:01:22.666238Z",
+     "start_time": "2025-06-25T07:01:22.660994Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "def vgg_block(in_channel,out_channel,num_convs):\n",
+    "    layers = nn.ModuleList()\n",
+    "    assert num_convs >= 1\n",
+    "    layers.append(nn.Conv2d(in_channel,out_channel,kernel_size=3,padding=1))\n",
+    "    layers.append(nn.ReLU())\n",
+    "    for _ in range(num_convs-1):\n",
+    "        layers.append(nn.Conv2d(out_channel,out_channel,kernel_size=3,padding=1))\n",
+    "        layers.append(nn.ReLU())\n",
+    "    layers.append(nn.MaxPool2d(kernel_size=2,stride=2))\n",
+    "    return nn.Sequential(*layers)\n",
+    "\n",
+    "VGG = nn.Sequential(\n",
+    "    vgg_block(1, 32, 2),  # 增加通道数和调整卷积层数量\n",
+    "    vgg_block(32, 64, 2),\n",
+    "    nn.Flatten(),\n",
+    "    nn.Linear(64 * 4 * 4, 256),  # 调整全连接层大小\n",
+    "    nn.BatchNorm1d(256),  # 添加批量归一化\n",
+    "    nn.ReLU(),\n",
+    "    nn.Dropout(0.5),  # 增加dropout比例\n",
+    "    nn.Linear(256, 128),\n",
+    "    nn.BatchNorm1d(128),  # 添加批量归一化\n",
+    "    nn.ReLU(),\n",
+    "    nn.Dropout(0.5),\n",
+    "    nn.Linear(128, 10),\n",
+    "    nn.Softmax(dim=-1)\n",
+    ")"
+   ],
+   "id": "f72e03c426bd658b",
+   "outputs": [],
+   "execution_count": 16
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T07:05:52.523565Z",
+     "start_time": "2025-06-25T07:01:22.782579Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# 修改VGG模型的训练参数\n",
+    "num_epochs = 300\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "vgg_model = VGG\n",
+    "vgg_model.to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.AdamW(vgg_model.parameters(), lr=3e-4, weight_decay=1e-5)  # 使用AdamW优化器和适当的权重衰减\n",
+    "vgg_model, metrics = train_model(vgg_model, criterion, optimizer, train_loader, valid_loader, num_epochs, device)\n",
+    "torch.save(vgg_model.state_dict(), './data/notebook2/vgg_weights.pt')   # 保存训练好的模型参数，用于后续的推理或测试\n",
+    "pd.DataFrame(metrics).to_csv('./data/notebook2/vgg_metrics.csv', index='None')   # 保存模型训练过程，用于后续图标展示"
+   ],
+   "id": "234337eef155a6de",
+   "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "<Figure size 1200x500 with 3 Axes>"
-      ],
-      "image/png": "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"
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Train loss: 1.563  Valid Acc: 0.855:  28%|██▊       | 85/300 [04:29<11:22,  3.17s/it]"
+     ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\n",
-      "Parameter Counts:\n",
-      "random_qccnn: 232581\n",
-      "qccnn: 26042\n",
-      "vgg: 49870\n"
+      "Early stopping at epoch 86 due to no improvement in validation accuracy.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
      ]
     }
    ],
-   "execution_count": 16
+   "execution_count": 17
   },
   {
-   "metadata": {},
-   "cell_type": "markdown",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T07:05:55.080402Z",
+     "start_time": "2025-06-25T07:05:52.668397Z"
+    }
+   },
+   "cell_type": "code",
    "source": [
-    "下面是新版本脚本相对于原始代码的主要改进点及对应说明，已结合关键代码片段进行标注：\n",
+    "state_dict = torch.load('./data/notebook2/vgg_weights.pt', map_location=device)\n",
+    "vgg_model = VGG\n",
+    "vgg_model.load_state_dict(state_dict)\n",
+    "vgg_model.to(device)\n",
     "\n",
-    "1. **数据增强（Data Augmentation）**\n",
-    "\n",
-    "   * **原始**：训练和验证都只做了 `Resize` + `ToTensor`，数据量固定；\n",
-    "   * **改进**：对训练集添加了 `RandomRotation`、`RandomHorizontalFlip`、`RandomVerticalFlip` 等操作，大幅增加了样本多样性，有助于提升模型泛化能力。\n",
-    "\n",
-    "   ```python\n",
-    "   train_transform = transforms.Compose([\n",
-    "       transforms.Resize((18, 18)),\n",
-    "       transforms.RandomRotation(15),            # 随机旋转\n",
-    "       transforms.RandomHorizontalFlip(),        # 随机水平翻转\n",
-    "       transforms.RandomVerticalFlip(0.3),       # 随机垂直翻转\n",
-    "       transforms.ToTensor(),\n",
-    "       transforms.Normalize((0.5,), (0.5,))\n",
-    "   ])\n",
-    "   ```\n",
-    "\n",
-    "2. **优化器与学习率调度**\n",
-    "\n",
-    "   * **原始**：`SGD(lr=0.01, weight_decay=0.001)` 或 `Adam(lr=1e-5)`，无学习率变化；\n",
-    "   * **改进**：统一使用 `AdamW`（带权重衰减的 Adam），更稳定；添加 `CosineAnnealingLR`，能在训练中动态调整学习率，促进更快收敛、更高精度。\n",
-    "\n",
-    "   ```python\n",
-    "   optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)\n",
-    "   scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)\n",
-    "   ```\n",
-    "\n",
-    "3. **批大小与训练轮次（Batch Size & Epochs）**\n",
-    "\n",
-    "   * **原始**：`batch_size=64`，`num_epochs=300`；\n",
-    "   * **改进**：增大到 `batch_size=128`，减少到 `num_epochs=50`。\n",
-    "\n",
-    "     * **批量更大**：更好利用 GPU 并行能力；\n",
-    "     * **轮次更少**：缩短训练时间，同时在学习率调度下仍能达到高准确度。\n",
-    "\n",
-    "4. **梯度裁剪（Gradient Clipping）**\n",
-    "\n",
-    "   * 增加了 `torch.nn.utils.clip_grad_norm_(…)`，避免量子网络中可能出现的梯度爆炸，保障训练稳定性。\n",
-    "\n",
-    "   ```python\n",
-    "   torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
-    "   ```\n",
-    "\n",
-    "5. **统一训练框架与多模型支持**\n",
-    "\n",
-    "   * 将原来三段几乎重复的训练逻辑，抽象成 `train_model(...)` 函数，并通过一个字典 `models` 循环一次性训练：\n",
-    "\n",
-    "     * `random_qccnn`、`qccnn`、`vgg` 三种架构统一流程；\n",
-    "     * 每种模型均保存最优权重（`save_path`）与训练曲线（`metrics.csv`）。\n",
-    "\n",
-    "   ```python\n",
-    "   models = {\n",
-    "       'random_qccnn': (RandomQCCNN(), 1e-3, './random_qccnn_best.pt'),\n",
-    "       'qccnn':        (QCCNN(),        1e-4, './qccnn_best.pt'),\n",
-    "       'vgg':          (VGG,            1e-4, './vgg_best.pt')\n",
-    "   }\n",
-    "   for name, (model, lr, save_path) in models.items():\n",
-    "       trained, metrics = train_model(\n",
-    "           model, criterion, optimizer, scheduler,\n",
-    "           train_loader, valid_loader,\n",
-    "           num_epochs=50, device=device, save_path=save_path\n",
-    "       )\n",
-    "       pd.DataFrame(metrics).to_csv(f'./{name}_metrics.csv', index=False)\n",
-    "   ```\n",
-    "\n",
-    "6. **最佳模型保存和测试分离**\n",
-    "\n",
-    "   * `train_model` 内部自动监控验证集准确率并保存最佳参数；\n",
-    "   * 训练结束后，再统一加载最佳权重进行测试，确保测试结果与最优状态对应。\n",
-    "\n",
-    "7. **可视化对比**\n",
-    "\n",
-    "   * 最后一个代码块中，通过 `matplotlib` 并排绘制三种模型的验证准确率曲线，直观比较不同模型的收敛速度和最终性能。\n",
-    "\n",
-    "   ```python\n",
-    "   plt.figure(figsize=(12,5))\n",
-    "   for i,(name,metrics) in enumerate(all_metrics.items(),1):\n",
-    "       plt.subplot(1,3,i)\n",
-    "       plt.plot(metrics['epoch'], metrics['valid_acc'], label=f'{name} Val Acc')\n",
-    "       plt.title(name); plt.legend()\n",
-    "   plt.tight_layout(); plt.show()\n",
-    "   ```\n",
-    "\n",
-    "8. **参数量统计**\n",
-    "\n",
-    "   * 在脚本末尾增加 `count_parameters` 函数，打印三种模型的可训练参数量，帮助评估模型复杂度与性能的权衡。\n",
-    "\n",
-    "   ```python\n",
-    "   def count_parameters(m):\n",
-    "       return sum(p.numel() for p in m.parameters() if p.requires_grad)\n",
-    "   for name,(model,_,_) in models.items():\n",
-    "       print(f\"{name}: {count_parameters(model)}\")\n",
-    "   ```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "**总体效果**：\n",
-    "\n",
-    "* **训练速度**：批量更大、轮次更少、学习率动态调度，整体训练时间显著缩短。\n",
-    "* **模型准确率**：数据增强 + 优化器 + 调度器 + 梯度裁剪等多项改进，显著提高了各模型在验证集和测试集上的准确率。\n",
-    "* **可维护性**：统一框架、函数抽象、循环训练及结果保存，大大简化了代码结构，便于后续扩展和调试。\n"
+    "vgg_test_acc = test_model(vgg_model, test_loader, device)"
    ],
-   "id": "6a5e9602f481107e"
+   "id": "ef857e4ec99a951a",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Acc: 0.894\n"
+     ]
+    }
+   ],
+   "execution_count": 18
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T07:05:55.325058Z",
+     "start_time": "2025-06-25T07:05:55.198007Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "vgg_data = pd.read_csv('./data/notebook2/vgg_metrics.csv')\n",
+    "qccnn_data = pd.read_csv('./data/notebook2/qccnn_metrics.csv')\n",
+    "vgg_epoch = vgg_data['epoch']\n",
+    "vgg_train_loss = vgg_data['train_loss']\n",
+    "vgg_valid_loss = vgg_data['valid_loss']\n",
+    "vgg_train_acc = vgg_data['train_acc']\n",
+    "vgg_valid_acc = vgg_data['valid_acc']\n",
+    "\n",
+    "qccnn_epoch = qccnn_data['epoch']\n",
+    "qccnn_train_loss = qccnn_data['train_loss']\n",
+    "qccnn_valid_loss = qccnn_data['valid_loss']\n",
+    "qccnn_train_acc = qccnn_data['train_acc']\n",
+    "qccnn_valid_acc = qccnn_data['valid_acc']\n",
+    "\n",
+    "# 创建图和Axes对象\n",
+    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n",
+    "\n",
+    "# 绘制训练损失曲线\n",
+    "ax1.plot(vgg_epoch, vgg_train_loss, label='VGG Train Loss')\n",
+    "ax1.plot(vgg_epoch, vgg_valid_loss, label='VGG Valid Loss')\n",
+    "ax1.plot(qccnn_epoch, qccnn_train_loss, label='QCCNN Valid Loss')\n",
+    "ax1.plot(qccnn_epoch, qccnn_valid_loss, label='QCCNN Valid Loss')\n",
+    "ax1.set_title('Training Loss Curve')\n",
+    "ax1.set_xlabel('Epoch')\n",
+    "ax1.set_ylabel('Loss')\n",
+    "ax1.legend()\n",
+    "\n",
+    "# 绘制训练准确率曲线\n",
+    "ax2.plot(vgg_epoch, vgg_train_acc, label='VGG Train Accuracy')\n",
+    "ax2.plot(vgg_epoch, vgg_valid_acc, label='VGG Valid Accuracy')\n",
+    "ax2.plot(qccnn_epoch, qccnn_train_acc, label='QCCNN Train Accuracy')\n",
+    "ax2.plot(qccnn_epoch, qccnn_valid_acc, label='QCCNN Valid Accuracy')\n",
+    "ax2.set_title('Training Accuracy Curve')\n",
+    "ax2.set_xlabel('Epoch')\n",
+    "ax2.set_ylabel('Accuracy')\n",
+    "ax2.legend()\n",
+    "\n",
+    "plt.show()"
+   ],
+   "id": "5d20475f38028031",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1200x500 with 2 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 19
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-25T07:05:55.477381Z",
+     "start_time": "2025-06-25T07:05:55.462043Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# 这里我们对比不同模型之间可训练参数量的区别\n",
+    "\n",
+    "def count_parameters(model):\n",
+    "    \"\"\"\n",
+    "    计算模型的参数数量\n",
+    "    \"\"\"\n",
+    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
+    "\n",
+    "number_params_VGG = count_parameters(VGG)\n",
+    "number_params_QCCNN = count_parameters(QCCNN())\n",
+    "print(f'VGG 模型可训练参数量：{number_params_VGG}\\t QCCNN模型可训练参数量：{number_params_QCCNN}')"
+   ],
+   "id": "72451dcf013280ac",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VGG 模型可训练参数量：362346\t QCCNN模型可训练参数量：26304\n"
+     ]
+    }
+   ],
+   "execution_count": 20
   }
  ],
  "metadata": {},
diff --git a/Modify.py b/Modify.py
index dcebaa7..2b2c7d6 100644
--- a/Modify.py
+++ b/Modify.py
@@ -1,291 +1,508 @@
-# Modify.py
-
-#%% 导入所有需要的包
+#%%
+# 首先我们导入所有需要的包：
 import os
 import random
 
 import numpy as np
 import pandas as pd
-import deepquantum as dq
-import matplotlib.pyplot as plt
 import torch
 import torch.nn as nn
 import torch.optim as optim
 import torchvision.transforms as transforms
-from torchvision.datasets import FashionMNIST
 from tqdm import tqdm
+from sklearn.metrics import roc_auc_score
 from torch.utils.data import DataLoader
-from multiprocessing import freeze_support
+from torchvision.datasets import FashionMNIST
+import deepquantum as dq
+import matplotlib.pyplot as plt
 
-#%% 设置随机种子以保证可复现
 def seed_torch(seed=1024):
+    """
+    Set random seeds for reproducibility.
+
+    Args:
+        seed (int): Random seed number to use. Default is 1024.
+    """
+
     random.seed(seed)
     os.environ['PYTHONHASHSEED'] = str(seed)
     np.random.seed(seed)
     torch.manual_seed(seed)
     torch.cuda.manual_seed(seed)
+
+    # Seed all GPUs with the same seed if using multi-GPU
     torch.cuda.manual_seed_all(seed)
     torch.backends.cudnn.benchmark = False
     torch.backends.cudnn.deterministic = True
 
-#%% 准确率计算函数
+seed_torch(42)  # 使用更常见的随机种子值
+#%%
 def calculate_score(y_true, y_preds):
+    # 将模型预测结果转为概率分布
     preds_prob = torch.softmax(y_preds, dim=1)
+    # 获得预测的类别（概率最高的一类）
     preds_class = torch.argmax(preds_prob, dim=1)
+    # 计算准确率
     correct = (preds_class == y_true).float()
-    return (correct.sum() / len(correct)).cpu().numpy()
+    accuracy = correct.sum() / len(correct)
+    return accuracy.cpu().numpy()
 
-#%% 训练与验证函数
-def train_model(model, criterion, optimizer, scheduler, train_loader, valid_loader, num_epochs, device, save_path):
-    model.to(device)
-    best_acc = 0.0
-    metrics = {'epoch': [], 'train_acc': [], 'valid_acc': [], 'train_loss': [], 'valid_loss': []}
 
-    for epoch in range(1, num_epochs + 1):
-        # --- 训练阶段 ---
-        model.train()
-        running_loss, running_acc = 0.0, 0.0
-        for imgs, labels in train_loader:
-            imgs, labels = imgs.to(device), labels.to(device)
-            optimizer.zero_grad()
-            outputs = model(imgs)
-            loss = criterion(outputs, labels)
-            loss.backward()
-            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
-            optimizer.step()
-            running_loss += loss.item()
-            running_acc += calculate_score(labels, outputs)
+def train_model(model, criterion, optimizer, train_loader, valid_loader, num_epochs, device):
+    """
+    训练和验证模型。
 
-        train_loss = running_loss / len(train_loader)
-        train_acc = running_acc / len(train_loader)
-        scheduler.step()
+    Args:
+        model (torch.nn.Module): 要训练的模型。
+        criterion (torch.nn.Module): 损失函数。
+        optimizer (torch.optim.Optimizer): 优化器。
+        train_loader (torch.utils.data.DataLoader): 训练数据加载器。
+        valid_loader (torch.utils.data.DataLoader): 验证数据加载器。
+        num_epochs (int): 训练的epoch数。
 
-        # --- 验证阶段 ---
-        model.eval()
-        val_loss, val_acc = 0.0, 0.0
-        with torch.no_grad():
-            for imgs, labels in valid_loader:
-                imgs, labels = imgs.to(device), labels.to(device)
-                outputs = model(imgs)
+    Returns:
+        model (torch.nn.Module): 训练后的模型。
+    """
+
+    model.train()
+    train_loss_list = []
+    valid_loss_list = []
+    train_acc_list = []
+    valid_acc_list = []
+
+    best_valid_acc = 0.0
+    patience = 10  # 早停耐心值
+    counter = 0   # 计数器
+
+    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=10)
+
+    with tqdm(total=num_epochs) as pbar:
+        for epoch in range(num_epochs):
+            # 训练阶段
+            train_loss = 0.0
+            train_acc = 0.0
+            for images, labels in train_loader:
+                images = images.to(device)
+                labels = labels.to(device)
+                optimizer.zero_grad()
+                outputs = model(images)
                 loss = criterion(outputs, labels)
-                val_loss += loss.item()
-                val_acc += calculate_score(labels, outputs)
+                loss.backward()
+                optimizer.step()
+                train_loss += loss.item()
+                train_acc += calculate_score(labels, outputs)
 
-        valid_loss = val_loss / len(valid_loader)
-        valid_acc = val_acc / len(valid_loader)
+            train_loss /= len(train_loader)
+            train_acc /= len(train_loader)
 
-        metrics['epoch'].append(epoch)
-        metrics['train_loss'].append(train_loss)
-        metrics['valid_loss'].append(valid_loss)
-        metrics['train_acc'].append(train_acc)
-        metrics['valid_acc'].append(valid_acc)
+            # 验证阶段
+            model.eval()
+            valid_loss = 0.0
+            valid_acc = 0.0
+            with torch.no_grad():
+                for images, labels in valid_loader:
+                    images = images.to(device)
+                    labels = labels.to(device)
+                    outputs = model(images)
+                    loss = criterion(outputs, labels)
+                    valid_loss += loss.item()
+                    valid_acc += calculate_score(labels, outputs)
 
-        tqdm.write(f"[{save_path}] Epoch {epoch}/{num_epochs}  "
-                   f"Train Acc: {train_acc:.4f}  Valid Acc: {valid_acc:.4f}")
+            valid_loss /= len(valid_loader)
+            valid_acc /= len(valid_loader)
+
+            # 学习率调度器更新
+            scheduler.step(valid_acc)
+
+            # 早停机制
+            if valid_acc > best_valid_acc:
+                best_valid_acc = valid_acc
+                torch.save(model.state_dict(), './data/notebook2/best_model.pt')
+                counter = 0
+            else:
+                counter += 1
+
+            if counter >= patience:
+                print(f'Early stopping at epoch {epoch+1} due to no improvement in validation accuracy.')
+                break
+
+            pbar.set_description(f"Train loss: {train_loss:.3f}  Valid Acc: {valid_acc:.3f}")
+            pbar.update()
+
+
+            train_loss_list.append(train_loss)
+            valid_loss_list.append(valid_loss)
+            train_acc_list.append(train_acc)
+            valid_acc_list.append(valid_acc)
+
+    # 加载最佳模型权重
+    if os.path.exists('./data/notebook2/best_model.pt'):
+        model.load_state_dict(torch.load('./data/notebook2/best_model.pt'))
+
+    # 修改metrics构建方式，确保各数组长度一致
+    metrics = {
+        'epoch': list(range(1, len(train_loss_list) + 1)),
+        'train_acc': train_acc_list,
+        'valid_acc': valid_acc_list,
+        'train_loss': train_loss_list,
+        'valid_loss': valid_loss_list
+    }
 
-        if valid_acc > best_acc:
-            best_acc = valid_acc
-            torch.save(model.state_dict(), save_path)
 
     return model, metrics
 
-#%% 测试函数
 def test_model(model, test_loader, device):
-    model.to(device).eval()
-    acc = 0.0
+    model.eval()
+    test_acc = 0.0
     with torch.no_grad():
-        for imgs, labels in test_loader:
-            imgs, labels = imgs.to(device), labels.to(device)
-            outputs = model(imgs)
-            acc += calculate_score(labels, outputs)
-    acc /= len(test_loader)
-    print(f"Test Accuracy: {acc:.4f}")
-    return acc
+        for images, labels in test_loader:
+            images = images.to(device)
+            labels = labels.to(device)
+            outputs = model(images)
+            test_acc += calculate_score(labels, outputs)
 
-#%% 定义量子卷积层与模型
-singlegate_list = ['rx','ry','rz','s','t','p','u3']
-doublegate_list = ['rxx','ryy','rzz','swap','cnot','cp','ch','cu','ct','cz']
+        test_acc /= len(test_loader)
+        print(f'Test Acc: {test_acc:.3f}')
+    return test_acc
+#%%
+# 定义图像变换
+trans1 = transforms.Compose([
+    transforms.RandomHorizontalFlip(),  # 随机水平翻转
+    transforms.RandomRotation(10),     # 随机旋转±10度
+    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 颜色调整
+    transforms.Resize((18, 18)),       # 调整大小为18x18
+    transforms.ToTensor(),           # 转换为张量
+    transforms.Normalize((0.5,), (0.5,))  # 归一化到[-1, 1]
+])
 
+trans2 = transforms.Compose([
+    transforms.RandomHorizontalFlip(),  # 随机水平翻转
+    transforms.RandomRotation(10),     # 随机旋转±10度
+    transforms.ColorJitter(brightness=0.2, contrast=0.2),  # 颜色调整
+    transforms.Resize((16, 16)),       # 调整大小为16x16
+    transforms.ToTensor(),           # 转换为张量
+    transforms.Normalize((0.5,), (0.5,))  # 归一化到[-1, 1]
+])
+train_dataset = FashionMNIST(root='./data/notebook2', train=False, transform=trans1,download=True)
+test_dataset = FashionMNIST(root='./data/notebook2', train=False, transform=trans1,download=True)
+
+# 定义训练集和测试集的比例
+train_ratio = 0.8  # 训练集比例为80%，验证集比例为20%
+valid_ratio = 0.2
+total_samples = len(train_dataset)
+train_size = int(train_ratio * total_samples)
+valid_size = int(valid_ratio * total_samples)
+
+# 分割训练集和测试集
+train_dataset, valid_dataset = torch.utils.data.random_split(train_dataset, [train_size, valid_size])
+
+# 加载随机抽取的训练数据集
+train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)
+valid_loader = DataLoader(valid_dataset, batch_size=64, shuffle=False, drop_last=True)
+test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, drop_last=True)
+#%%
+singlegate_list = ['rx', 'ry', 'rz', 's', 't', 'p', 'u3']
+doublegate_list = ['rxx', 'ryy', 'rzz', 'swap', 'cnot', 'cp', 'ch', 'cu', 'ct', 'cz']
+#%%
+# 随机量子卷积层
 class RandomQuantumConvolutionalLayer(nn.Module):
-    def __init__(self, nqubit, num_circuits, seed=1024):
-        super().__init__()
+    def __init__(self, nqubit, num_circuits, seed:int=1024):
+        super(RandomQuantumConvolutionalLayer, self).__init__()
         random.seed(seed)
         self.nqubit = nqubit
         self.cirs = nn.ModuleList([self.circuit(nqubit) for _ in range(num_circuits)])
+
     def circuit(self, nqubit):
         cir = dq.QubitCircuit(nqubit)
-        cir.rxlayer(encode=True); cir.barrier()
-        for _ in range(3):
+        cir.rxlayer(encode=True)  # 对原论文的量子线路结构并无影响，只是做了一个数据编码的操作
+        cir.barrier()
+        for iter in range(3):
             for i in range(nqubit):
-                getattr(cir, random.choice(singlegate_list))(i)
-            c,t = random.sample(range(nqubit),2)
-            gate = random.choice(doublegate_list)
-            if gate[0] in ['r','s']:
-                getattr(cir, gate)([c,t])
+                singlegate = random.choice(singlegate_list)
+                getattr(cir, singlegate)(i)
+            control_bit, target_bit = random.sample(range(0, nqubit - 1), 2)
+            doublegate = random.choice(doublegate_list)
+            if doublegate[0] in ['r', 's']:
+                getattr(cir, doublegate)([control_bit, target_bit])
             else:
-                getattr(cir, gate)(c,t)
+                getattr(cir, doublegate)(control_bit, target_bit)
             cir.barrier()
+
         cir.observable(0)
         return cir
-    def forward(self, x):
-        k,s = 2,2
-        x_unf = x.unfold(2,k,s).unfold(3,k,s)
-        w = (x.shape[-1]-k)//s + 1
-        x_r = x_unf.reshape(-1, self.nqubit)
-        exps = []
-        for cir in self.cirs:
-            cir(x_r)
-            exps.append(cir.expectation())
-        exps = torch.stack(exps,1).reshape(x.size(0), len(self.cirs), w, w)
-        return exps
 
+    def forward(self, x):
+        kernel_size, stride = 2, 2
+        # [64, 1, 18, 18] -> [64, 1, 9, 18, 2] -> [64, 1, 9, 9, 2, 2]
+        x_unflod = x.unfold(2, kernel_size, stride).unfold(3, kernel_size, stride)
+        w = int((x.shape[-1] - kernel_size) / stride + 1)
+        x_reshape = x_unflod.reshape(-1, self.nqubit)
+
+        exps = []
+        for cir in self.cirs: # out_channels
+            cir(x_reshape)
+            exp = cir.expectation()
+            exps.append(exp)
+
+        exps = torch.stack(exps, dim=1)
+        exps = exps.reshape(x.shape[0], 3, w, w)
+        return exps
+#%%
+net = RandomQuantumConvolutionalLayer(nqubit=4, num_circuits=3, seed=1024)
+net.cirs[0].draw()
+#%%
+# 基于随机量子卷积层的混合模型
 class RandomQCCNN(nn.Module):
     def __init__(self):
-        super().__init__()
+        super(RandomQCCNN, self).__init__()
         self.conv = nn.Sequential(
-            RandomQuantumConvolutionalLayer(4,3,seed=1024),
-            nn.ReLU(), nn.MaxPool2d(2,1),
-            nn.Conv2d(3,6,2,1), nn.ReLU(), nn.MaxPool2d(2,1)
+            RandomQuantumConvolutionalLayer(nqubit=4, num_circuits=3, seed=1024),   # num_circuits=3代表我们在quanv1层只用了3个量子卷积核
+            nn.BatchNorm2d(3),  # 添加批量归一化
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=1),
+            nn.Conv2d(3, 6, kernel_size=2, stride=1),
+            nn.BatchNorm2d(6),  # 添加批量归一化
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=1)
         )
         self.fc = nn.Sequential(
-            nn.Linear(6*6*6,1024), nn.Dropout(0.4),
-            nn.Linear(1024,10)
+            nn.Linear(6 * 6 * 6, 1024),
+            nn.BatchNorm1d(1024),  # 添加批量归一化
+            nn.Dropout(0.5),  # 增加dropout比例
+            nn.ReLU(),
+            nn.Linear(1024, 10)
         )
-    def forward(self,x):
-        x = self.conv(x)
-        x = x.view(x.size(0),-1)
-        return self.fc(x)
 
+    def forward(self, x):
+        x = self.conv(x)
+        x = x.reshape(x.size(0), -1)
+        x = self.fc(x)
+        return x
+#%%
+# 修改RandomQCCNN模型的训练参数
+num_epochs = 300
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(device)
+seed_torch(42)   # 使用相同的随机种子值
+model = RandomQCCNN()
+model.to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-5)  # 使用AdamW优化器和适当的权重衰减
+optim_model, metrics = train_model(model, criterion, optimizer, train_loader, valid_loader, num_epochs, device)
+torch.save(optim_model.state_dict(), './data/notebook2/random_qccnn_weights.pt')   # 保存训练好的模型参数，用于后续的推理或测试
+pd.DataFrame(metrics).to_csv('./data/notebook2/random_qccnn_metrics.csv', index='None')   # 保存模型训练过程，用于后续图标展示
+#%%
+state_dict = torch.load('./data/notebook2/random_qccnn_weights.pt', map_location=device)
+random_qccnn_model = RandomQCCNN()
+random_qccnn_model.load_state_dict(state_dict)
+random_qccnn_model.to(device)
+
+test_acc = test_model(random_qccnn_model, test_loader, device)
+#%%
+data = pd.read_csv('./data/notebook2/random_qccnn_metrics.csv')
+epoch = data['epoch']
+train_loss = data['train_loss']
+valid_loss = data['valid_loss']
+train_acc = data['train_acc']
+valid_acc = data['valid_acc']
+
+# 创建图和Axes对象
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+
+# 绘制训练损失曲线
+ax1.plot(epoch, train_loss, label='Train Loss')
+ax1.plot(epoch, valid_loss, label='Valid Loss')
+ax1.set_title('Training Loss Curve')
+ax1.set_xlabel('Epoch')
+ax1.set_ylabel('Loss')
+ax1.legend()
+
+# 绘制训练准确率曲线
+ax2.plot(epoch, train_acc, label='Train Accuracy')
+ax2.plot(epoch, valid_acc, label='Valid Accuracy')
+ax2.set_title('Training Accuracy Curve')
+ax2.set_xlabel('Epoch')
+ax2.set_ylabel('Accuracy')
+ax2.legend()
+
+plt.show()
+#%%
 class ParameterizedQuantumConvolutionalLayer(nn.Module):
-    def __init__(self,nqubit,num_circuits):
+    def __init__(self, nqubit, num_circuits):
         super().__init__()
         self.nqubit = nqubit
         self.cirs = nn.ModuleList([self.circuit(nqubit) for _ in range(num_circuits)])
-    def circuit(self,nqubit):
+
+    def circuit(self, nqubit):
         cir = dq.QubitCircuit(nqubit)
-        cir.rxlayer(encode=True); cir.barrier()
-        for _ in range(4):
-            cir.rylayer(); cir.cnot_ring(); cir.barrier()
+        cir.rxlayer(encode=True)  #对原论文的量子线路结构并无影响，只是做了一个数据编码的操作
+        cir.barrier()
+        for iter in range(4): #对应原论文中一个量子卷积线路上的深度为4，可控参数一共16个
+            cir.rylayer()
+            cir.cnot_ring()
+            cir.barrier()
+
         cir.observable(0)
         return cir
-    def forward(self,x):
-        k,s = 2,2
-        x_unf = x.unfold(2,k,s).unfold(3,k,s)
-        w = (x.shape[-1]-k)//s +1
-        x_r = x_unf.reshape(-1,self.nqubit)
-        exps = []
-        for cir in self.cirs:
-            cir(x_r); exps.append(cir.expectation())
-        exps = torch.stack(exps,1).reshape(x.size(0),len(self.cirs),w,w)
-        return exps
 
+    def forward(self, x):
+        kernel_size, stride = 2, 2
+        # [64, 1, 18, 18] -> [64, 1, 9, 18, 2] -> [64, 1, 9, 9, 2, 2]
+        x_unflod = x.unfold(2, kernel_size, stride).unfold(3, kernel_size, stride)
+        w = int((x.shape[-1] - kernel_size) / stride + 1)
+        x_reshape = x_unflod.reshape(-1, self.nqubit)
+
+        exps = []
+        for cir in self.cirs: # out_channels
+            cir(x_reshape)
+            exp = cir.expectation()
+            exps.append(exp)
+
+        exps = torch.stack(exps, dim=1)
+        exps = exps.reshape(x.shape[0], 3, w, w)
+        return exps
+#%%
+# 此处我们可视化其中一个量子卷积核的线路结构：
+net = ParameterizedQuantumConvolutionalLayer(nqubit=4, num_circuits=3)
+net.cirs[0].draw()
+#%%
+# QCCNN整体网络架构：
 class QCCNN(nn.Module):
     def __init__(self):
-        super().__init__()
+        super(QCCNN, self).__init__()
         self.conv = nn.Sequential(
-            ParameterizedQuantumConvolutionalLayer(4,3),
-            nn.ReLU(), nn.MaxPool2d(2,1)
+            ParameterizedQuantumConvolutionalLayer(nqubit=4, num_circuits=3),
+            nn.BatchNorm2d(3),  # 添加批量归一化
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=1)
         )
-        self.fc = nn.Sequential(
-            nn.Linear(8*8*3,128), nn.Dropout(0.4), nn.ReLU(),
-            nn.Linear(128,10)
-        )
-    def forward(self,x):
-        x = self.conv(x); x = x.view(x.size(0),-1)
-        return self.fc(x)
 
-def vgg_block(in_c,out_c,n_convs):
-    layers = [nn.Conv2d(in_c,out_c,3,padding=1), nn.ReLU()]
-    for _ in range(n_convs-1):
-        layers += [nn.Conv2d(out_c,out_c,3,padding=1), nn.ReLU()]
-    layers.append(nn.MaxPool2d(2,2))
+        self.fc = nn.Sequential(
+            nn.Linear(8 * 8 * 3, 128),
+            nn.BatchNorm1d(128),  # 添加批量归一化
+            nn.Dropout(0.5),  # 增加dropout比例
+            nn.ReLU(),
+            nn.Linear(128, 10)
+        )
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = x.reshape(x.size(0), -1)
+        x = self.fc(x)
+        return x
+#%%
+# 修改QCCNN模型的训练参数
+num_epochs = 300
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = QCCNN()
+model.to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=1e-5)  # 使用AdamW优化器和适当的权重衰减
+optim_model, metrics = train_model(model, criterion, optimizer, train_loader, valid_loader, num_epochs, device)
+torch.save(optim_model.state_dict(), './data/notebook2/qccnn_weights.pt')   # 保存训练好的模型参数，用于后续的推理或测试
+pd.DataFrame(metrics).to_csv('./data/notebook2/qccnn_metrics.csv', index='None')   # 保存模型训练过程，用于后续图标展示
+#%%
+state_dict = torch.load('./data/notebook2/qccnn_weights.pt', map_location=device)
+qccnn_model = QCCNN()
+qccnn_model.load_state_dict(state_dict)
+qccnn_model.to(device)
+
+test_acc = test_model(qccnn_model, test_loader, device)
+#%%
+def vgg_block(in_channel,out_channel,num_convs):
+    layers = nn.ModuleList()
+    assert num_convs >= 1
+    layers.append(nn.Conv2d(in_channel,out_channel,kernel_size=3,padding=1))
+    layers.append(nn.ReLU())
+    for _ in range(num_convs-1):
+        layers.append(nn.Conv2d(out_channel,out_channel,kernel_size=3,padding=1))
+        layers.append(nn.ReLU())
+    layers.append(nn.MaxPool2d(kernel_size=2,stride=2))
     return nn.Sequential(*layers)
 
 VGG = nn.Sequential(
-    vgg_block(1,10,3),
-    vgg_block(10,16,3),
+    vgg_block(1, 32, 2),  # 增加通道数和调整卷积层数量
+    vgg_block(32, 64, 2),
     nn.Flatten(),
-    nn.Linear(16*4*4,120), nn.Sigmoid(),
-    nn.Linear(120,84), nn.Sigmoid(),
-    nn.Linear(84,10), nn.Softmax(dim=-1)
+    nn.Linear(64 * 4 * 4, 256),  # 调整全连接层大小
+    nn.BatchNorm1d(256),  # 添加批量归一化
+    nn.ReLU(),
+    nn.Dropout(0.5),  # 增加dropout比例
+    nn.Linear(256, 128),
+    nn.BatchNorm1d(128),  # 添加批量归一化
+    nn.ReLU(),
+    nn.Dropout(0.5),
+    nn.Linear(128, 10),
+    nn.Softmax(dim=-1)
 )
+#%%
+# 修改VGG模型的训练参数
+num_epochs = 300
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-#%% 主入口
-if __name__ == '__main__':
-    freeze_support()
+vgg_model = VGG
+vgg_model.to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(vgg_model.parameters(), lr=3e-4, weight_decay=1e-5)  # 使用AdamW优化器和适当的权重衰减
+vgg_model, metrics = train_model(vgg_model, criterion, optimizer, train_loader, valid_loader, num_epochs, device)
+torch.save(vgg_model.state_dict(), './data/notebook2/vgg_weights.pt')   # 保存训练好的模型参数，用于后续的推理或测试
+pd.DataFrame(metrics).to_csv('./data/notebook2/vgg_metrics.csv', index='None')   # 保存模型训练过程，用于后续图标展示
+#%%
+state_dict = torch.load('./data/notebook2/vgg_weights.pt', map_location=device)
+vgg_model = VGG
+vgg_model.load_state_dict(state_dict)
+vgg_model.to(device)
 
-    # 数据增广与加载
-    train_transform = transforms.Compose([
-        transforms.Resize((18, 18)),
-        transforms.RandomRotation(15),
-        transforms.RandomHorizontalFlip(),
-        transforms.RandomVerticalFlip(0.3),
-        transforms.ToTensor(),
-        transforms.Normalize((0.5,), (0.5,))
-    ])
-    eval_transform = transforms.Compose([
-        transforms.Resize((18, 18)),
-        transforms.ToTensor(),
-        transforms.Normalize((0.5,), (0.5,))
-    ])
+vgg_test_acc = test_model(vgg_model, test_loader, device)
+#%%
+vgg_data = pd.read_csv('./data/notebook2/vgg_metrics.csv')
+qccnn_data = pd.read_csv('./data/notebook2/qccnn_metrics.csv')
+vgg_epoch = vgg_data['epoch']
+vgg_train_loss = vgg_data['train_loss']
+vgg_valid_loss = vgg_data['valid_loss']
+vgg_train_acc = vgg_data['train_acc']
+vgg_valid_acc = vgg_data['valid_acc']
 
-    full_train = FashionMNIST(root='./data/notebook2', train=True, transform=train_transform, download=True)
-    test_dataset = FashionMNIST(root='./data/notebook2', train=False, transform=eval_transform, download=True)
-    train_size = int(0.8 * len(full_train))
-    valid_size = len(full_train) - train_size
-    train_ds, valid_ds = torch.utils.data.random_split(full_train, [train_size, valid_size])
-    valid_ds.dataset.transform = eval_transform
+qccnn_epoch = qccnn_data['epoch']
+qccnn_train_loss = qccnn_data['train_loss']
+qccnn_valid_loss = qccnn_data['valid_loss']
+qccnn_train_acc = qccnn_data['train_acc']
+qccnn_valid_acc = qccnn_data['valid_acc']
 
-    batch_size = 128
-    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True,  drop_last=True, num_workers=4)
-    valid_loader = DataLoader(valid_ds, batch_size=batch_size, shuffle=False, drop_last=True, num_workers=4)
-    test_loader  = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, drop_last=False, num_workers=4)
+# 创建图和Axes对象
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
 
-    # 三种模型配置
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    models = {
-        'random_qccnn': (RandomQCCNN(), 1e-3, './data/notebook2/random_qccnn_best.pt'),
-        'qccnn':        (QCCNN(),        1e-4, './data/notebook2/qccnn_best.pt'),
-        'vgg':          (VGG,            1e-4, './data/notebook2/vgg_best.pt')
-    }
+# 绘制训练损失曲线
+ax1.plot(vgg_epoch, vgg_train_loss, label='VGG Train Loss')
+ax1.plot(vgg_epoch, vgg_valid_loss, label='VGG Valid Loss')
+ax1.plot(qccnn_epoch, qccnn_train_loss, label='QCCNN Valid Loss')
+ax1.plot(qccnn_epoch, qccnn_valid_loss, label='QCCNN Valid Loss')
+ax1.set_title('Training Loss Curve')
+ax1.set_xlabel('Epoch')
+ax1.set_ylabel('Loss')
+ax1.legend()
 
-    all_metrics = {}
-    for name, (model, lr, save_path) in models.items():
-        seed_torch(1024)
-        model = model.to(device)
-        criterion = nn.CrossEntropyLoss()
-        optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
-        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+# 绘制训练准确率曲线
+ax2.plot(vgg_epoch, vgg_train_acc, label='VGG Train Accuracy')
+ax2.plot(vgg_epoch, vgg_valid_acc, label='VGG Valid Accuracy')
+ax2.plot(qccnn_epoch, qccnn_train_acc, label='QCCNN Train Accuracy')
+ax2.plot(qccnn_epoch, qccnn_valid_acc, label='QCCNN Valid Accuracy')
+ax2.set_title('Training Accuracy Curve')
+ax2.set_xlabel('Epoch')
+ax2.set_ylabel('Accuracy')
+ax2.legend()
 
-        print(f"\n=== Training {name} ===")
-        _, metrics = train_model(
-            model, criterion, optimizer, scheduler,
-            train_loader, valid_loader,
-            num_epochs=50, device=device, save_path=save_path
-        )
-        all_metrics[name] = metrics
-        pd.DataFrame(metrics).to_csv(f'./data/notebook2/{name}_metrics.csv', index=False)
+plt.show()
+#%%
+# 这里我们对比不同模型之间可训练参数量的区别
 
-    # 测试与可视化
-    plt.figure(figsize=(12,5))
-    for i,(name,metrics) in enumerate(all_metrics.items(),1):
-        model, _, save_path = models[name]
-        best_model = model.to(device)
-        best_model.load_state_dict(torch.load(save_path))
-        print(f"\n--- Testing {name} ---")
-        test_model(best_model, test_loader, device)
+def count_parameters(model):
+    """
+    计算模型的参数数量
+    """
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
 
-        plt.subplot(1,3,i)
-        plt.plot(metrics['epoch'], metrics['valid_acc'], label=f'{name} Val Acc')
-        plt.xlabel('Epoch'); plt.ylabel('Valid Acc')
-        plt.title(name); plt.legend()
-
-    plt.tight_layout(); plt.show()
-
-    # 参数量统计
-    def count_parameters(m):
-        return sum(p.numel() for p in m.parameters() if p.requires_grad)
-
-    print("\nParameter Counts:")
-    for name,(model,_,_) in models.items():
-        print(f"{name}: {count_parameters(model)}")
+number_params_VGG = count_parameters(VGG)
+number_params_QCCNN = count_parameters(QCCNN())
+print(f'VGG 模型可训练参数量：{number_params_VGG}\t QCCNN模型可训练参数量：{number_params_QCCNN}')
\ No newline at end of file
diff --git a/data/notebook1/random_qccnn_metrics.csv b/data/notebook1/random_qccnn_metrics.csv
index 74e20a4..62ce43d 100644
--- a/data/notebook1/random_qccnn_metrics.csv
+++ b/data/notebook1/random_qccnn_metrics.csv
@@ -1,301 +1,33 @@
 ,epoch,train_acc,valid_acc,train_loss,valid_loss
-0,1,0.12575,0.21421370967741934,2.2937231807708742,2.2676862593620055
-1,2,0.248,0.3240927419354839,2.2377592124938963,2.1976155081102924
-2,3,0.354375,0.3815524193548387,2.129876153945923,2.044375258107339
-3,4,0.42625,0.4324596774193548,1.9269471073150635,1.815262294584705
-4,5,0.482125,0.5282258064516129,1.6988583679199218,1.6081839684517152
-5,6,0.528375,0.5151209677419355,1.5167635107040405,1.4654438649454424
-6,7,0.5465,0.5574596774193549,1.3927514476776124,1.3655932180343135
-7,8,0.5705,0.5403225806451613,1.3035813112258912,1.2985444838000881
-8,9,0.586875,0.5902217741935484,1.2359741706848144,1.2315824993195073
-9,10,0.5985,0.5967741935483871,1.1828507437705993,1.1789349471369097
-10,11,0.61075,0.6013104838709677,1.1400936079025268,1.146019495302631
-11,12,0.61425,0.6098790322580645,1.105873393535614,1.1111935800121677
-12,13,0.623,0.6234879032258065,1.076672074317932,1.089227545645929
-13,14,0.63475,0.6159274193548387,1.0523606872558593,1.0597389667264876
-14,15,0.63575,0.5866935483870968,1.0302134299278258,1.0517296521894393
-15,16,0.638625,0.625,1.0127733755111694,1.030857661078053
-16,17,0.644125,0.623991935483871,0.9972539176940918,1.0212982143125227
-17,18,0.647125,0.6491935483870968,0.9847306752204895,1.0031032081573241
-18,19,0.651625,0.6295362903225806,0.9718224520683288,0.9922776433729357
-19,20,0.653375,0.655241935483871,0.9614444556236267,1.004007081831655
-20,21,0.65475,0.639616935483871,0.9525526990890503,0.9718767077692093
-21,22,0.657125,0.6491935483870968,0.944016770362854,0.9612755986952013
-22,23,0.660125,0.6512096774193549,0.9386747822761535,0.9546890701017072
-23,24,0.660125,0.6607862903225806,0.9306546316146851,0.9596057341944787
-24,25,0.665625,0.6466733870967742,0.9239095873832702,0.9440147549875321
-25,26,0.664,0.6537298387096774,0.9177467222213745,0.9464947581291199
-26,27,0.66675,0.6582661290322581,0.912406234741211,0.9296330482729019
-27,28,0.66625,0.6607862903225806,0.9084503087997436,0.9246035218238831
-28,29,0.669375,0.6633064516129032,0.9031522455215454,0.9183507677047483
-29,30,0.66925,0.6622983870967742,0.8971806693077088,0.9155043325116557
-30,31,0.669625,0.6658266129032258,0.8963782095909119,0.9107550824842146
-31,32,0.6715,0.6607862903225806,0.8907575702667236,0.9062397806875168
-32,33,0.672875,0.6592741935483871,0.8865971283912659,0.9067775895518642
-33,34,0.6755,0.6643145161290323,0.8831153435707092,0.8996775977073177
-34,35,0.6745,0.6643145161290323,0.8799522204399108,0.9008925057226612
-35,36,0.67625,0.6738911290322581,0.8765962233543396,0.8957007392760246
-36,37,0.67775,0.6602822580645161,0.8732238512039184,0.8957233851955783
-37,38,0.677,0.6663306451612904,0.8700605201721191,0.8884582346485507
-38,39,0.677625,0.6779233870967742,0.86691774892807,0.8847945544027513
-39,40,0.683875,0.6683467741935484,0.8638643326759339,0.8812634848779247
-40,41,0.6825,0.6703629032258065,0.8619350233078003,0.8736868096936133
-41,42,0.68525,0.6769153225806451,0.8574845008850097,0.8757798306403621
-42,43,0.68325,0.6829637096774194,0.8559755001068116,0.8762649028531967
-43,44,0.681875,0.6794354838709677,0.8526963171958923,0.868664155083318
-44,45,0.6855,0.670866935483871,0.8508440051078796,0.8656267696811307
-45,46,0.687375,0.6738911290322581,0.8477729640007019,0.8647398410304901
-46,47,0.689125,0.6723790322580645,0.844515609741211,0.8638435967506901
-47,48,0.685,0.6779233870967742,0.8429114985466003,0.8618940441839157
-48,49,0.689125,0.6794354838709677,0.8397265086174012,0.8545605559502879
-49,50,0.686625,0.6804435483870968,0.8384793972969056,0.8552838506237153
-50,51,0.691125,0.6774193548387096,0.8345498304367065,0.848295844370319
-51,52,0.687875,0.6859879032258065,0.8335188755989075,0.855028792735069
-52,53,0.691,0.6824596774193549,0.8311837863922119,0.8479280106482967
-53,54,0.692875,0.6859879032258065,0.8279946088790894,0.8404466413682506
-54,55,0.6925,0.6804435483870968,0.8260387935638428,0.84263696593623
-55,56,0.693125,0.6849798387096774,0.8229942922592163,0.8379247784614563
-56,57,0.694375,0.6844758064516129,0.8220300149917602,0.8415298577277891
-57,58,0.696375,0.6880040322580645,0.8190384802818298,0.8321282882844249
-58,59,0.694,0.6875,0.816288417339325,0.8343535277151293
-59,60,0.694875,0.6839717741935484,0.8151030368804931,0.8336188389408973
-60,61,0.69425,0.6854838709677419,0.8126006669998169,0.8352141207264315
-61,62,0.697125,0.6854838709677419,0.8106505064964294,0.8332801768856664
-62,63,0.69975,0.6905241935483871,0.8080810284614564,0.8234034065277346
-63,64,0.70075,0.6844758064516129,0.8052171502113342,0.8192608933294973
-64,65,0.69925,0.6869959677419355,0.8035496191978455,0.815050482749939
-65,66,0.7005,0.6875,0.8014146156311035,0.8252233305285054
-66,67,0.698125,0.6905241935483871,0.7996929430961609,0.8083832244719228
-67,68,0.69975,0.6895161290322581,0.7969387445449829,0.8108954429626465
-68,69,0.702125,0.6869959677419355,0.7955113248825073,0.8145994409438102
-69,70,0.7,0.6935483870967742,0.792340503692627,0.807374858087109
-70,71,0.702625,0.6950604838709677,0.7911754889488221,0.8086352617509903
-71,72,0.703625,0.6985887096774194,0.7885409245491027,0.8008877135092213
-72,73,0.70425,0.702116935483871,0.7873198952674866,0.7998276199063947
-73,74,0.704125,0.6970766129032258,0.7848704538345337,0.7971179581457569
-74,75,0.70625,0.6970766129032258,0.7822935285568238,0.7927621314602513
-75,76,0.70475,0.6960685483870968,0.7788817420005798,0.7937883177111226
-76,77,0.704875,0.6985887096774194,0.7792668890953064,0.7862545732528933
-77,78,0.703625,0.7006048387096774,0.7767630572319031,0.7841528077279368
-78,79,0.710875,0.6980846774193549,0.7729922785758973,0.7877849590393805
-79,80,0.7085,0.7036290322580645,0.7725881729125976,0.7884936524975684
-80,81,0.7145,0.6975806451612904,0.7703448913097382,0.7794140846498551
-81,82,0.707875,0.703125,0.7683381514549256,0.7827766460757102
-82,83,0.71425,0.704133064516129,0.7661359086036682,0.7740850121744217
-83,84,0.716,0.7247983870967742,0.7635970077514649,0.7837481344899824
-84,85,0.714625,0.7046370967741935,0.7620524802207946,0.7760492024883148
-85,86,0.717875,0.7273185483870968,0.7587687454223633,0.7693652645234139
-86,87,0.71925,0.7167338709677419,0.7571495487689972,0.7791498034231125
-87,88,0.723125,0.7061491935483871,0.7559212753772736,0.7657425865050285
-88,89,0.721125,0.7227822580645161,0.7540467400550842,0.7639261926374128
-89,90,0.72775,0.7212701612903226,0.7519344382286072,0.7616109309657928
-90,91,0.72775,0.7283266129032258,0.7487852301597595,0.7575869021877166
-91,92,0.727875,0.7273185483870968,0.7474929718971253,0.7539062634591134
-92,93,0.72625,0.7237903225806451,0.744426561832428,0.7515108796858019
-93,94,0.7285,0.717741935483871,0.7436468710899353,0.7493124450406721
-94,95,0.72875,0.7227822580645161,0.7407840843200684,0.7509921366168607
-95,96,0.731875,0.7232862903225806,0.7383509948253631,0.7504203108049208
-96,97,0.732125,0.7288306451612904,0.7363486151695251,0.7452502135307558
-97,98,0.732875,0.7283266129032258,0.7337991933822632,0.7476337955844018
-98,99,0.735625,0.7303427419354839,0.7317234919071197,0.739826298529102
-99,100,0.733625,0.7283266129032258,0.7287046048641205,0.739542922665996
-100,101,0.73375,0.7147177419354839,0.7274810273647309,0.7344657682603405
-101,102,0.7355,0.7338709677419355,0.7247261893749237,0.7346700814462477
-102,103,0.73225,0.733366935483871,0.7240956840515137,0.7285718571755194
-103,104,0.737,0.7247983870967742,0.720921181678772,0.7279678198599047
-104,105,0.73725,0.7162298387096774,0.7193985497951507,0.7334578460262667
-105,106,0.73975,0.7232862903225806,0.7166938002109527,0.728367522839577
-106,107,0.737875,0.7363911290322581,0.715068681716919,0.7223057727659902
-107,108,0.742625,0.7318548387096774,0.7129860005378723,0.7190377539204013
-108,109,0.74,0.7389112903225806,0.7117807359695435,0.7183994016339702
-109,110,0.739875,0.7384072580645161,0.7105983903408051,0.7164657365891242
-110,111,0.742375,0.7328629032258065,0.7074811918735504,0.7246334398946455
-111,112,0.74,0.7348790322580645,0.7077446887493134,0.7127827925066794
-112,113,0.740125,0.7348790322580645,0.7058010087013245,0.7185006468526779
-113,114,0.74125,0.7379032258064516,0.7062028846740722,0.711994872939202
-114,115,0.741375,0.734375,0.7025900321006775,0.722117660507079
-115,116,0.741875,0.7404233870967742,0.702047369480133,0.7054055179319074
-116,117,0.741,0.7368951612903226,0.7008094470500946,0.7059461897419345
-117,118,0.74,0.7379032258064516,0.7000908722877502,0.7077065225570432
-118,119,0.74275,0.7389112903225806,0.697608702659607,0.7044590307820228
-119,120,0.741125,0.735383064516129,0.6974484593868255,0.705822677381577
-120,121,0.745,0.7363911290322581,0.6940790374279022,0.726842547616651
-121,122,0.741875,0.7409274193548387,0.6941187741756439,0.6984606769777113
-122,123,0.7455,0.7363911290322581,0.6942173736095428,0.7010489721452037
-123,124,0.74125,0.7404233870967742,0.6926323885917663,0.704462626288014
-124,125,0.743875,0.7409274193548387,0.6916290044784545,0.696697513903341
-125,126,0.74375,0.7394153225806451,0.6898484938144683,0.6978444207099176
-126,127,0.743625,0.7399193548387096,0.6888203046321869,0.7016230494745316
-127,128,0.74525,0.7414314516129032,0.6875256526470185,0.6972026151995505
-128,129,0.744125,0.7414314516129032,0.686995727300644,0.6930867991139812
-129,130,0.748,0.7424395161290323,0.6873089451789856,0.6934665374217495
-130,131,0.744,0.7328629032258065,0.6838541362285614,0.7066772426328352
-131,132,0.7435,0.7363911290322581,0.6849607121944428,0.6904300124414505
-132,133,0.746,0.7444556451612904,0.6836790750026703,0.6916862668529633
-133,134,0.746125,0.7419354838709677,0.6825263681411743,0.6903918568165072
-134,135,0.747125,0.7454637096774194,0.6808646347522735,0.6892580957181992
-135,136,0.746625,0.7328629032258065,0.6810887951850891,0.6992948112949249
-136,137,0.747625,0.7399193548387096,0.6801265494823456,0.6914754644516976
-137,138,0.744125,0.7449596774193549,0.6794462163448334,0.686861309313005
-138,139,0.746375,0.7379032258064516,0.6796345655918121,0.6865283789173249
-139,140,0.74825,0.7363911290322581,0.6776200189590454,0.6895612343665092
-140,141,0.748375,0.7368951612903226,0.6769659533500672,0.6895686657198014
-141,142,0.745875,0.7409274193548387,0.6762004556655884,0.684873923178642
-142,143,0.75,0.7429435483870968,0.6766425142288208,0.6841276749487846
-143,144,0.7495,0.7429435483870968,0.6757207989692688,0.6857355977258375
-144,145,0.74775,0.7409274193548387,0.6757489387989044,0.6874895538053205
-145,146,0.75275,0.7358870967741935,0.6723645563125611,0.6919096823661558
-146,147,0.75125,0.7399193548387096,0.672961886882782,0.6845684782151253
-147,148,0.751375,0.7389112903225806,0.672047397851944,0.6911592175883632
-148,149,0.7485,0.7399193548387096,0.6713605234622956,0.6868368666018209
-149,150,0.749625,0.7434475806451613,0.6715062477588654,0.6797055390573317
-150,151,0.752,0.7429435483870968,0.6708727264404297,0.6786900566470239
-151,152,0.749375,0.7404233870967742,0.6705182585716247,0.6893971793113216
-152,153,0.756375,0.7409274193548387,0.6681198358535767,0.6818877074026293
-153,154,0.74875,0.7323588709677419,0.668769829750061,0.6870744218749385
-154,155,0.751375,0.7404233870967742,0.6693622040748596,0.6791631608240066
-155,156,0.7495,0.7384072580645161,0.6677224984169007,0.6791054318028111
-156,157,0.751125,0.7530241935483871,0.6669107344150543,0.6757311301846658
-157,158,0.750375,0.7454637096774194,0.6689134707450867,0.675748364579293
-158,159,0.749875,0.7394153225806451,0.665742442369461,0.6785702628474082
-159,160,0.755125,0.7439516129032258,0.6639340476989746,0.6909028849294109
-160,161,0.754375,0.7484879032258065,0.6655936982631684,0.6800686274805376
-161,162,0.753,0.7444556451612904,0.6626871073246002,0.6847033404534862
-162,163,0.754375,0.7394153225806451,0.6636988418102264,0.678314108041025
-163,164,0.756,0.7439516129032258,0.6631928851604462,0.679127223068668
-164,165,0.7535,0.7449596774193549,0.6635311431884766,0.6755695458381407
-165,166,0.75425,0.7439516129032258,0.6608122355937958,0.6740436525114121
-166,167,0.7535,0.751008064516129,0.6623840556144714,0.6725323296362354
-167,168,0.753375,0.7474798387096774,0.6615988018512726,0.6734585973524279
-168,169,0.7555,0.7404233870967742,0.658470029592514,0.6751049209025598
-169,170,0.75275,0.748991935483871,0.6596595213413239,0.6707770478340888
-170,171,0.75475,0.7464717741935484,0.6594919128417969,0.6760938773232121
-171,172,0.752375,0.7404233870967742,0.6587064244747162,0.6735088594498173
-172,173,0.754875,0.7419354838709677,0.6581688785552978,0.6718735867930997
-173,174,0.755625,0.7444556451612904,0.6594367871284484,0.672063180515843
-174,175,0.75675,0.7484879032258065,0.6572930109500885,0.6681920395743463
-175,176,0.7565,0.7555443548387096,0.6567469036579132,0.666823229482097
-176,177,0.75625,0.7242943548387096,0.6563848433494568,0.69633928614278
-177,178,0.7545,0.7520161290322581,0.6568190479278564,0.6688290171084865
-178,179,0.758125,0.7464717741935484,0.6569823319911957,0.668416089588596
-179,180,0.756125,0.7474798387096774,0.6567688817977906,0.6825112623553122
-180,181,0.75825,0.7384072580645161,0.6541404497623443,0.6793540994967183
-181,182,0.754125,0.7484879032258065,0.6573447947502136,0.6673893765095742
-182,183,0.7575,0.7459677419354839,0.6545488471984864,0.669147877923904
-183,184,0.757625,0.7520161290322581,0.653099508523941,0.6698833357903266
-184,185,0.7575,0.7459677419354839,0.652852609872818,0.6746915771115211
-185,186,0.75775,0.7469758064516129,0.6531596164703369,0.6692096014176646
-186,187,0.75625,0.7429435483870968,0.65095947265625,0.6785491474213139
-187,188,0.759875,0.748991935483871,0.6528274257183075,0.6676096195174802
-188,189,0.75825,0.751008064516129,0.6515383367538452,0.6677034651079485
-189,190,0.761,0.7429435483870968,0.6507666997909546,0.6711848301272239
-190,191,0.756,0.7505040322580645,0.6502130575180054,0.6673150216379473
-191,192,0.755625,0.7520161290322581,0.6508474731445313,0.6693628420752864
-192,193,0.758375,0.7449596774193549,0.6497379775047303,0.6839032778816838
-193,194,0.760125,0.7449596774193549,0.6500401992797852,0.6711471715281087
-194,195,0.7595,0.751008064516129,0.6485152614116668,0.6667885655356992
-195,196,0.761,0.751008064516129,0.6486285464763641,0.6671426277006826
-196,197,0.76,0.7515120967741935,0.6487596340179443,0.6690003919985986
-197,198,0.759375,0.7494959677419355,0.6480154263973236,0.6674725115299225
-198,199,0.761125,0.7494959677419355,0.6471124620437622,0.6651709810380013
-199,200,0.7585,0.7389112903225806,0.6480610625743866,0.6811543289692171
-200,201,0.75975,0.7379032258064516,0.6461314346790313,0.6756981101728254
-201,202,0.759375,0.7459677419354839,0.6457764523029328,0.6665134122294765
-202,203,0.75775,0.7550403225806451,0.6469809007644653,0.661889091614754
-203,204,0.761125,0.7479838709677419,0.6435232808589936,0.6644216324052503
-204,205,0.760375,0.7439516129032258,0.6471346819400787,0.6682568625096352
-205,206,0.762,0.7414314516129032,0.6459955296516419,0.6739240298348088
-206,207,0.75925,0.7540322580645161,0.6436120250225067,0.6613490379625752
-207,208,0.764875,0.7484879032258065,0.6442920634746552,0.665196894638
-208,209,0.7595,0.7439516129032258,0.6450260980129242,0.66756044376281
-209,210,0.762375,0.7525201612903226,0.6450640928745269,0.6618116507607121
-210,211,0.764125,0.7479838709677419,0.6432662625312805,0.6611761902609179
-211,212,0.76175,0.7464717741935484,0.6430184645652771,0.6601478543973738
-212,213,0.7635,0.7540322580645161,0.6424563028812409,0.6675388928382627
-213,214,0.76075,0.7464717741935484,0.6431009001731872,0.6693989961378036
-214,215,0.763375,0.7545362903225806,0.6424487299919128,0.6593958552806608
-215,216,0.759875,0.7550403225806451,0.6421677529811859,0.6666595695480224
-216,217,0.760625,0.7464717741935484,0.6414295537471771,0.6686101180891837
-217,218,0.76525,0.7545362903225806,0.641946748971939,0.663229928862664
-218,219,0.759875,0.751008064516129,0.6410156943798065,0.6790805785886703
-219,220,0.76,0.7484879032258065,0.6424972369670868,0.6616327435739578
-220,221,0.7605,0.751008064516129,0.6389381773471833,0.6645574127474139
-221,222,0.763125,0.7515120967741935,0.6390037200450898,0.6623315830384532
-222,223,0.761,0.7570564516129032,0.6397264943122863,0.6680223576484188
-223,224,0.76425,0.7520161290322581,0.6378453469276428,0.6630678580653283
-224,225,0.763875,0.7520161290322581,0.6382321789264679,0.662065879952523
-225,226,0.762,0.7479838709677419,0.639366191625595,0.661988039170542
-226,227,0.765,0.7525201612903226,0.6383702094554902,0.6641764746558282
-227,228,0.763125,0.751008064516129,0.6380119869709014,0.6607372049362429
-228,229,0.759375,0.7520161290322581,0.6383262400627137,0.6545132811992399
-229,230,0.764375,0.7555443548387096,0.6372324013710022,0.6568373855083219
-230,231,0.761625,0.7484879032258065,0.6373445687294006,0.6696269560244775
-231,232,0.76475,0.7515120967741935,0.6373440618515015,0.6574311083362948
-232,233,0.768,0.7555443548387096,0.6352594494819641,0.6599096617391033
-233,234,0.7635,0.7464717741935484,0.6361170980930329,0.6795821391767071
-234,235,0.76175,0.75,0.6369703621864319,0.6554409640450631
-235,236,0.765,0.7535282258064516,0.6348738882541657,0.6552178427096336
-236,237,0.762625,0.7520161290322581,0.6365966260433197,0.6692352737149885
-237,238,0.7645,0.7449596774193549,0.6336214027404785,0.688425297698667
-238,239,0.76525,0.7560483870967742,0.6345989825725555,0.6607512629801228
-239,240,0.7625,0.7479838709677419,0.6337947535514832,0.65921801136386
-240,241,0.764,0.7515120967741935,0.6340638983249665,0.6573365686401245
-241,242,0.767,0.7535282258064516,0.6342987337112427,0.6604504883289337
-242,243,0.768,0.7444556451612904,0.6332927324771881,0.671097691020658
-243,244,0.76475,0.7520161290322581,0.6348397693634034,0.6558002243118901
-244,245,0.76675,0.7474798387096774,0.632552001953125,0.6722479366487072
-245,246,0.768,0.748991935483871,0.6314238250255585,0.6594607532024384
-246,247,0.764875,0.7444556451612904,0.6325469689369202,0.6605463912410121
-247,248,0.7655,0.7525201612903226,0.6310685338973999,0.6538672639477637
-248,249,0.766,0.7570564516129032,0.6316399626731872,0.6516222578863944
-249,250,0.766125,0.7515120967741935,0.6315728986263275,0.6539699367938503
-250,251,0.764625,0.7479838709677419,0.6300767264366149,0.6660763275238776
-251,252,0.768375,0.7525201612903226,0.6311213612556458,0.6618637481043416
-252,253,0.764375,0.75,0.6319745321273804,0.6553429893908962
-253,254,0.765125,0.7484879032258065,0.6321416351795196,0.6639243306652192
-254,255,0.765125,0.7424395161290323,0.6311585788726807,0.6792801503212221
-255,256,0.766125,0.7575604838709677,0.6310848982334137,0.6525870225121898
-256,257,0.767625,0.7520161290322581,0.6288257777690888,0.6681103860178301
-257,258,0.7655,0.7550403225806451,0.6306543848514556,0.659768590042668
-258,259,0.764,0.7555443548387096,0.6302573113441468,0.6550669179808709
-259,260,0.769125,0.7580645161290323,0.6280254762172699,0.6525000554900016
-260,261,0.76875,0.7540322580645161,0.6282578265666962,0.6584180526195034
-261,262,0.76775,0.7560483870967742,0.6287466604709625,0.6528177463239239
-262,263,0.770375,0.7409274193548387,0.6289410617351532,0.6700733111750695
-263,264,0.76825,0.7515120967741935,0.628407103061676,0.6540230772187633
-264,265,0.7675,0.7520161290322581,0.630276577949524,0.6641475250644069
-265,266,0.767875,0.7530241935483871,0.6273887372016906,0.6583489189224858
-266,267,0.76625,0.7535282258064516,0.6282406325340271,0.6604514862260511
-267,268,0.76925,0.7535282258064516,0.6271086316108704,0.6536620384262454
-268,269,0.76825,0.7469758064516129,0.6269893596172332,0.6587162335072795
-269,270,0.767125,0.7479838709677419,0.6261151025295257,0.6642194390296936
-270,271,0.768,0.7545362903225806,0.62709636926651,0.659077537636603
-271,272,0.767875,0.7575604838709677,0.626769639968872,0.6581989363316567
-272,273,0.768625,0.7570564516129032,0.6237564489841462,0.6504895312170829
-273,274,0.767875,0.7540322580645161,0.6259858434200287,0.6550556219393208
-274,275,0.76925,0.7565524193548387,0.6264045915603638,0.6529571308243659
-275,276,0.768375,0.7605846774193549,0.6264821493625641,0.6480650353816247
-276,277,0.767375,0.7585685483870968,0.6253943295478821,0.6529869091126227
-277,278,0.768,0.7585685483870968,0.6250380325317383,0.6509808676858102
-278,279,0.77225,0.7560483870967742,0.6249497833251954,0.652328065326137
-279,280,0.768375,0.7610887096774194,0.6253566663265229,0.6481388095886477
-280,281,0.769,0.7631048387096774,0.6269658114910126,0.6511666505567489
-281,282,0.77225,0.7615927419354839,0.6219663026332856,0.6503843261349586
-282,283,0.768375,0.7530241935483871,0.6239040396213531,0.6559025366460124
-283,284,0.773125,0.7565524193548387,0.6230207705497741,0.6521498032154576
-284,285,0.77225,0.7575604838709677,0.6224600894451141,0.6498911640336437
-285,286,0.772375,0.7535282258064516,0.6230463716983795,0.6594464038648913
-286,287,0.772125,0.7454637096774194,0.623299633026123,0.6596774737681111
-287,288,0.7705,0.7575604838709677,0.6226675305366516,0.6503997896948168
-288,289,0.771875,0.7615927419354839,0.6228007516860962,0.6582970378860351
-289,290,0.769,0.7610887096774194,0.6228819963932037,0.6468615512694081
-290,291,0.77075,0.7560483870967742,0.6219233012199402,0.6543603664444338
-291,292,0.770125,0.7570564516129032,0.6231648538112641,0.6516289316838787
-292,293,0.772625,0.7555443548387096,0.6210650091171265,0.6526086061231552
-293,294,0.7735,0.7580645161290323,0.6205819368362426,0.650269466061746
-294,295,0.76975,0.7600806451612904,0.6209871962070465,0.6479213949172727
-295,296,0.770125,0.7565524193548387,0.6204864876270294,0.6524337001385228
-296,297,0.76875,0.7464717741935484,0.622816385269165,0.6591307309366041
-297,298,0.771375,0.7585685483870968,0.620723108291626,0.647264729584417
-298,299,0.768625,0.7580645161290323,0.621616400718689,0.6502204921937758
-299,300,0.7725,0.7555443548387096,0.6198663051128388,0.6479197202190277
+0,1,0.59325,0.6854838709677419,1.1784187927246095,0.8956879992638865
+1,2,0.713,0.7127016129032258,0.788702152967453,0.7735376723351017
+2,3,0.755,0.7389112903225806,0.7006268813610077,0.7271041427889178
+3,4,0.763625,0.7273185483870968,0.668900458574295,0.7277685692233424
+4,5,0.76275,0.748991935483871,0.6469288661479949,0.672559670863613
+5,6,0.773625,0.7434475806451613,0.6203210880756378,0.6748099394382969
+6,7,0.771625,0.7494959677419355,0.6234635796546936,0.6763338706185741
+7,8,0.784125,0.7580645161290323,0.5965014040470124,0.6313219945276937
+8,9,0.781,0.7419354838709677,0.5893729448318481,0.6552943125847848
+9,10,0.785375,0.7600806451612904,0.582163923740387,0.6227685501498561
+10,11,0.790625,0.7605846774193549,0.5674120993614197,0.6145914264263646
+11,12,0.7995,0.765625,0.5617314722537995,0.6158498919779255
+12,13,0.7965,0.7883064516129032,0.5522617139816284,0.581030644716755
+13,14,0.803125,0.7817540322580645,0.5367116575241089,0.5911272004727395
+14,15,0.80025,0.7752016129032258,0.5398472018241882,0.5930967292478008
+15,16,0.808125,0.7620967741935484,0.5326456694602967,0.6306540206555398
+16,17,0.8145,0.7772177419354839,0.5097175936698913,0.5843374094655437
+17,18,0.817375,0.7918346774193549,0.5045695571899415,0.5643920071663395
+18,19,0.81175,0.7681451612903226,0.5022978014945984,0.593349628871487
+19,20,0.824375,0.7928427419354839,0.4974315061569214,0.5595071181174247
+20,21,0.818,0.7762096774193549,0.49526858401298524,0.5555580258369446
+21,22,0.815625,0.7862903225806451,0.4976941578388214,0.5627694274148634
+22,23,0.825875,0.7908266129032258,0.4906779823303223,0.5514134312829664
+23,24,0.823875,0.7953629032258065,0.4869117760658264,0.5559701804191836
+24,25,0.823,0.7807459677419355,0.48527450203895567,0.5541293746040713
+25,26,0.824625,0.795866935483871,0.4811685870885849,0.5384060884675672
+26,27,0.827875,0.7938508064516129,0.48096660792827606,0.5493545234203339
+27,28,0.826875,0.7998991935483871,0.477142098903656,0.5478304624557495
+28,29,0.82725,0.7948588709677419,0.47373487854003904,0.547797841410483
+29,30,0.825375,0.7847782258064516,0.47746446084976196,0.5636355328944421
+30,31,0.828875,0.7757056451612904,0.4754366238117218,0.5671144060550197
+31,32,0.8315,0.7908266129032258,0.4769072663784027,0.5523799340571126
diff --git a/data/notebook1/random_qccnn_weights.pt b/data/notebook1/random_qccnn_weights.pt
index bca4431..06bdf9d 100644
Binary files a/data/notebook1/random_qccnn_weights.pt and b/data/notebook1/random_qccnn_weights.pt differ
diff --git a/data/notebook2/best_model.pt b/data/notebook2/best_model.pt
new file mode 100644
index 0000000..433ffb2
Binary files /dev/null and b/data/notebook2/best_model.pt differ
diff --git a/data/notebook2/qccnn_metrics.csv b/data/notebook2/qccnn_metrics.csv
index 4a094fc..6fdd053 100644
--- a/data/notebook2/qccnn_metrics.csv
+++ b/data/notebook2/qccnn_metrics.csv
@@ -1,51 +1,49 @@
-epoch,train_acc,valid_acc,train_loss,valid_loss
-1,0.3112916666666667,0.5076444892473119,2.1129255460103353,1.7863053237238238
-2,0.46210416666666665,0.5547715053763441,1.5605127541224162,1.3499009532313193
-3,0.5200833333333333,0.5892137096774194,1.298180630683899,1.1617528520604616
-4,0.5641666666666667,0.6311323924731183,1.161390997727712,1.0419180438082705
-5,0.6055833333333334,0.6598622311827957,1.062113331158956,0.9560088053826363
-6,0.6316666666666667,0.6804435483870968,0.9944041889508565,0.8958990977656457
-7,0.6513958333333333,0.6928763440860215,0.9395476338068645,0.8504296951396491
-8,0.6677708333333333,0.7007728494623656,0.8985106336275737,0.8148919709267155
-9,0.6809375,0.7095934139784946,0.8673048818906148,0.7897684433126962
-10,0.6876666666666666,0.7185819892473119,0.8408271819750468,0.7671139176173877
-11,0.697625,0.7247143817204301,0.8202435002326965,0.7502269674372929
-12,0.7030625,0.7303427419354839,0.8024592914581299,0.7343912464316174
-13,0.7118958333333333,0.7316868279569892,0.7869214735031128,0.7222210591839205
-14,0.7163958333333333,0.7404233870967742,0.7718908907572428,0.7093277560767307
-15,0.7211041666666667,0.7437836021505376,0.7589795832633972,0.6981546148177116
-16,0.724875,0.748067876344086,0.7483940289815267,0.6881407947950465
-17,0.7293958333333334,0.75,0.7373875479698181,0.6788085179944192
-18,0.7345,0.7517641129032258,0.7301613558133443,0.6724013622089099
-19,0.7350416666666667,0.7550403225806451,0.7210039290587107,0.6651292238184201
-20,0.7391458333333333,0.758736559139785,0.711990216255188,0.6584682823509298
-21,0.7433958333333334,0.7608366935483871,0.7047773049672444,0.6513981505106854
-22,0.7442916666666667,0.7634408602150538,0.6997552577654521,0.6454382868864204
-23,0.7481458333333333,0.7653729838709677,0.6937046423753103,0.6401395256160408
-24,0.7498333333333334,0.7683131720430108,0.6873725473880767,0.6349253362865859
-25,0.7529166666666667,0.769573252688172,0.6828897857666015,0.6308066611007977
-26,0.7547291666666667,0.7708333333333334,0.6747500312328338,0.6260690948655528
-27,0.7547291666666667,0.7722614247311828,0.6727884339491527,0.6230032514500362
-28,0.7580208333333334,0.7736055107526881,0.6705719958146413,0.6201616948650729
-29,0.757125,0.7748655913978495,0.6678872625033061,0.6165956912502166
-30,0.76025,0.7759576612903226,0.6641453323364258,0.6141596103227267
-31,0.7609583333333333,0.7767137096774194,0.6619020007451375,0.6114715427480718
-32,0.7618333333333334,0.776377688172043,0.6576849890549977,0.609050533463878
-33,0.7629583333333333,0.7783938172043011,0.6566993356545766,0.6069687149857962
-34,0.7631666666666667,0.7791498655913979,0.6553838003476461,0.6052348261238426
-35,0.7626666666666667,0.7785618279569892,0.6523663277626037,0.6037159392269709
-36,0.7653333333333333,0.780325940860215,0.6526273953914642,0.6023694485105494
-37,0.7639791666666667,0.7810819892473119,0.6524330813884736,0.6012957778669172
-38,0.7673958333333334,0.7799059139784946,0.6500039516290029,0.6002496516191831
-39,0.764875,0.7815860215053764,0.6476710465749105,0.5992967845291219
-40,0.7661041666666667,0.782258064516129,0.6484741485118866,0.5987250285763894
-41,0.7668333333333334,0.7818380376344086,0.64447620677948,0.5979425240588444
-42,0.7662291666666666,0.7817540322580645,0.6458657967249553,0.5976644568545844
-43,0.76675,0.7824260752688172,0.6449048202037811,0.5971484975789183
-44,0.7677916666666667,0.7825100806451613,0.6437487976551056,0.5968063899906733
-45,0.7677083333333333,0.7825940860215054,0.6432626353104909,0.5964810960395361
-46,0.7666041666666666,0.7826780913978495,0.6452286802132925,0.5963560240243071
-47,0.768875,0.7827620967741935,0.6432473388512929,0.5962550809947393
-48,0.7674583333333334,0.7826780913978495,0.6433716455300649,0.5961945524779699
-49,0.7678333333333334,0.7827620967741935,0.6440556212266286,0.596176440036425
-50,0.7677083333333333,0.7825940860215054,0.6438165396849315,0.5961719805835396
+,epoch,train_acc,valid_acc,train_loss,valid_loss
+0,1,0.391375,0.5882056451612904,1.7793689422607422,1.3356874796652025
+1,2,0.617125,0.6365927419354839,1.059556163787842,0.9690603344671188
+2,3,0.663125,0.6577620967741935,0.9102170023918151,0.9078671547674364
+3,4,0.69,0.6819556451612904,0.8537670917510987,0.8649420180628377
+4,5,0.71125,0.7056451612903226,0.8021836678981781,0.8317571128568342
+5,6,0.719375,0.6844758064516129,0.7773117737770081,0.8293971457789021
+6,7,0.733,0.7247983870967742,0.7432277894020081,0.7570091389840649
+7,8,0.727125,0.7051411290322581,0.7392586808204651,0.7708722833664187
+8,9,0.740375,0.7091733870967742,0.716008551120758,0.7547545788749572
+9,10,0.74775,0.7091733870967742,0.6988923935890198,0.7634256799374858
+10,11,0.75025,0.7328629032258065,0.6836859595775604,0.7220065324537216
+11,12,0.75525,0.7313508064516129,0.6790840411186219,0.7320531125991575
+12,13,0.755875,0.734375,0.6686462206840516,0.7067360877990723
+13,14,0.755875,0.7338709677419355,0.659578008890152,0.6924379564100697
+14,15,0.758625,0.7217741935483871,0.6591809678077698,0.7092515037905786
+15,16,0.770125,0.7474798387096774,0.6366513178348542,0.6689942498360911
+16,17,0.76975,0.75,0.64143789935112,0.6781372427940369
+17,18,0.766625,0.7469758064516129,0.6327295961380005,0.6749444469328849
+18,19,0.772125,0.7298387096774194,0.6213552060127259,0.6950428524324971
+19,20,0.771625,0.7560483870967742,0.619529750585556,0.6620656597998834
+20,21,0.77425,0.7459677419354839,0.6170263500213623,0.6944894117693747
+21,22,0.77375,0.7379032258064516,0.610548350572586,0.698592597438443
+22,23,0.774125,0.7494959677419355,0.6073116481304168,0.6649176555295144
+23,24,0.78,0.75,0.601892656326294,0.6502023070089279
+24,25,0.777875,0.7671370967741935,0.5965238115787506,0.6416350141648324
+25,26,0.7875,0.751008064516129,0.584319313287735,0.6557927843063108
+26,27,0.784625,0.7651209677419355,0.5858220131397247,0.6265111680953733
+27,28,0.77975,0.7610887096774194,0.5928270950317382,0.6353864400617538
+28,29,0.780625,0.7520161290322581,0.5824392430782318,0.6569667564284417
+29,30,0.78475,0.7686491935483871,0.5810435285568237,0.6306867743692091
+30,31,0.789,0.7706653225806451,0.5672282783985138,0.6261125274242894
+31,32,0.78525,0.7560483870967742,0.5757509377002716,0.6505500414679127
+32,33,0.792,0.7681451612903226,0.5613697295188904,0.629849144527989
+33,34,0.793875,0.7620967741935484,0.5625830183029175,0.6189906856706066
+34,35,0.791875,0.7681451612903226,0.5602230775356293,0.6212261732547514
+35,36,0.794625,0.7615927419354839,0.5545250961780548,0.619811047469416
+36,37,0.794625,0.7701612903225806,0.5573954427242279,0.6205428954093687
+37,38,0.79425,0.764616935483871,0.5514744529724122,0.628905875067557
+38,39,0.792375,0.7842741935483871,0.5618353080749512,0.5954909113145643
+39,40,0.796375,0.7711693548387096,0.5491654114723206,0.6137347759739045
+40,41,0.799,0.7641129032258065,0.5372960684299469,0.6470560056547965
+41,42,0.800375,0.7671370967741935,0.5395989503860473,0.6211921880322118
+42,43,0.806,0.7671370967741935,0.5370515692234039,0.6075864828401997
+43,44,0.801875,0.7605846774193549,0.5388010408878326,0.5891174308715328
+44,45,0.800875,0.766633064516129,0.539761929512024,0.610026998865989
+45,46,0.802375,0.780241935483871,0.5270701496601105,0.6000283591208919
+46,47,0.799875,0.7772177419354839,0.5320828959941865,0.5864833074231302
+47,48,0.807,0.7837701612903226,0.5309389193058014,0.5761975809451072
diff --git a/data/notebook2/qccnn_weights.pt b/data/notebook2/qccnn_weights.pt
new file mode 100644
index 0000000..c0fead2
Binary files /dev/null and b/data/notebook2/qccnn_weights.pt differ
diff --git a/data/notebook2/random_qccnn_metrics.csv b/data/notebook2/random_qccnn_metrics.csv
index 3050a59..c29a873 100644
--- a/data/notebook2/random_qccnn_metrics.csv
+++ b/data/notebook2/random_qccnn_metrics.csv
@@ -1,51 +1,34 @@
-epoch,train_acc,valid_acc,train_loss,valid_loss
-1,0.6377291666666667,0.7426075268817204,1.0222952149709066,0.6658745436899124
-2,0.7588541666666667,0.7799059139784946,0.6436424539883931,0.5876969707909451
-3,0.7829791666666667,0.7955309139784946,0.5888768948713938,0.5508138095178912
-4,0.7927916666666667,0.8009912634408602,0.5641531114578247,0.5473136597423143
-5,0.7997291666666667,0.8065356182795699,0.5444657148520152,0.515406842834206
-6,0.8043541666666667,0.8140120967741935,0.5316140202681223,0.5052012169873843
-7,0.80975,0.8156922043010753,0.521293937365214,0.4983856466508681
-8,0.8155208333333334,0.8162802419354839,0.5079634555180867,0.49958501611986467
-9,0.8161875,0.8159442204301075,0.5036936206022898,0.4907228536503289
-10,0.816875,0.8160282258064516,0.497530157327652,0.4895895427914076
-11,0.8210416666666667,0.8269489247311828,0.4916797243754069,0.47517218673101036
-12,0.8210416666666667,0.8266129032258065,0.4892559293905894,0.468310099135163
-13,0.8241041666666666,0.8211525537634409,0.4825246704419454,0.4856182368852759
-14,0.8239791666666667,0.8264448924731183,0.48390908201535543,0.46895075997998636
-15,0.8245,0.8230846774193549,0.4795244421164195,0.47176380727880746
-16,0.8270416666666667,0.829133064516129,0.47462198424339297,0.4671747069205007
-17,0.8273958333333333,0.8297211021505376,0.4733834793567657,0.4658442559421703
-18,0.828125,0.8337533602150538,0.47195579528808596,0.46035799896845253
-19,0.8294583333333333,0.829133064516129,0.4668528276284536,0.46208705472689804
-20,0.830625,0.8303931451612904,0.46666145197550457,0.4616392642580053
-21,0.8320416666666667,0.8280409946236559,0.46406093080838523,0.4690516353935324
-22,0.8315833333333333,0.8293010752688172,0.4628266294002533,0.4590829178210228
-23,0.8315416666666666,0.8298051075268817,0.46202420779069264,0.4582436110383721
-24,0.8328541666666667,0.8282090053763441,0.4594616918563843,0.46520241454083433
-25,0.8321458333333334,0.8313172043010753,0.45899707794189454,0.4611524093535639
-26,0.835,0.8311491935483871,0.4561348853111267,0.460902286793596
-27,0.8342708333333333,0.8335013440860215,0.45571692689259846,0.4524733103731627
-28,0.83475,0.831989247311828,0.45314634958902994,0.4535403392648184
-29,0.8353958333333333,0.8333333333333334,0.4508692183494568,0.4509869323622796
-30,0.8358958333333333,0.8314012096774194,0.4508490650653839,0.4559444804345408
-31,0.8379791666666667,0.8347614247311828,0.44810916344324747,0.45132114586009775
-32,0.8369375,0.832997311827957,0.4488534228801727,0.4531173186917459
-33,0.8375208333333334,0.8366935483870968,0.4460577855904897,0.4518213977095901
-34,0.8372708333333333,0.8314852150537635,0.4453533016045888,0.4571616124081355
-35,0.8381458333333334,0.8351814516129032,0.4446527805328369,0.4513627043975297
-36,0.8392916666666667,0.8373655913978495,0.4431237142880758,0.44869983228304056
-37,0.838375,0.8347614247311828,0.4424218458334605,0.4486082660895522
-38,0.8397916666666667,0.8355174731182796,0.4412206415732702,0.44703892129723743
-39,0.8401875,0.8365255376344086,0.4396123299598694,0.4470836206149029
-40,0.8399791666666667,0.8345934139784946,0.43971687642733254,0.4466231196157394
-41,0.8410833333333333,0.8373655913978495,0.43810279977321626,0.4461495735312021
-42,0.8408958333333333,0.8372815860215054,0.4371747978528341,0.4456534408113008
-43,0.8414583333333333,0.8363575268817204,0.43774009283383686,0.4454879440287108
-44,0.841375,0.8358534946236559,0.4363077602386475,0.4460145914426414
-45,0.8408958333333333,0.8363575268817204,0.43665687982241314,0.44518788110825325
-46,0.841875,0.8371135752688172,0.43598757874965666,0.44520101848468985
-47,0.8422083333333333,0.836945564516129,0.4349166991710663,0.44520143988311933
-48,0.8421041666666667,0.8360215053763441,0.43520630804697674,0.44510498354511874
-49,0.8416875,0.836861559139785,0.4354708949327469,0.44491737311886204
-50,0.8408125,0.836861559139785,0.43524290529886883,0.4449239748139535
+,epoch,train_acc,valid_acc,train_loss,valid_loss
+0,1,0.561125,0.6476814516129032,1.271985122203827,0.9911825291572078
+1,2,0.676375,0.6668346774193549,0.9134431419372558,0.8937955517922679
+2,3,0.699125,0.6824596774193549,0.8243759956359863,0.8520721235582905
+3,4,0.716625,0.6995967741935484,0.7818560593128204,0.8005917687569896
+4,5,0.725125,0.7101814516129032,0.745261854171753,0.8037946531849522
+5,6,0.733375,0.7061491935483871,0.7344184167385102,0.7732808570707997
+6,7,0.737875,0.7253024193548387,0.7150477197170257,0.74149090051651
+7,8,0.74325,0.7253024193548387,0.7022454526424408,0.7516527022084882
+8,9,0.742625,0.7298387096774194,0.7041031284332275,0.7247120468847214
+9,10,0.747875,0.7116935483870968,0.6772661633491516,0.7338270487323884
+10,11,0.757875,0.7212701612903226,0.6562292041778565,0.7387931039256435
+11,12,0.761625,0.7328629032258065,0.6542983632087708,0.725050816612859
+12,13,0.75925,0.7318548387096774,0.6493379819393158,0.7001086867624714
+13,14,0.767375,0.7379032258064516,0.6460576868057251,0.6988139988914612
+14,15,0.765875,0.7288306451612904,0.6339491362571716,0.7128441218406923
+15,16,0.763125,0.7368951612903226,0.6262373595237732,0.714297366719092
+16,17,0.76925,0.7227822580645161,0.6279029569625855,0.7181522269402781
+17,18,0.77025,0.7449596774193549,0.6159816448688507,0.6757595616002237
+18,19,0.7745,0.7283266129032258,0.6136245548725128,0.6998546681096477
+19,20,0.775375,0.7469758064516129,0.6000997524261474,0.6749713065162781
+20,21,0.7805,0.748991935483871,0.5928600332736969,0.6656959902855658
+21,22,0.77525,0.7444556451612904,0.599046837568283,0.6857193170055267
+22,23,0.785,0.7384072580645161,0.5875316572189331,0.6785462142959717
+23,24,0.778375,0.765625,0.588378502368927,0.627939272311426
+24,25,0.78575,0.7459677419354839,0.5700427904129028,0.6502643679418871
+25,26,0.7805,0.75,0.5785817315578461,0.6712307555060233
+26,27,0.78675,0.7474798387096774,0.5676946561336518,0.6555941143343526
+27,28,0.787875,0.7505040322580645,0.575938116312027,0.6507430134281036
+28,29,0.789,0.7605846774193549,0.5655779435634612,0.6520830373610219
+29,30,0.790625,0.7434475806451613,0.5578647639751434,0.6789213486256138
+30,31,0.787375,0.7565524193548387,0.5687701859474182,0.649224087115257
+31,32,0.79575,0.7560483870967742,0.5432633152008056,0.6388471222692921
+32,33,0.7895,0.7595766129032258,0.5557173223495483,0.6391933618053314
diff --git a/data/notebook2/random_qccnn_weights.pt b/data/notebook2/random_qccnn_weights.pt
new file mode 100644
index 0000000..e62e8ca
Binary files /dev/null and b/data/notebook2/random_qccnn_weights.pt differ
diff --git a/data/notebook2/vgg_metrics.csv b/data/notebook2/vgg_metrics.csv
index a0ee2e0..4631c19 100644
--- a/data/notebook2/vgg_metrics.csv
+++ b/data/notebook2/vgg_metrics.csv
@@ -1,51 +1,86 @@
-epoch,train_acc,valid_acc,train_loss,valid_loss
-1,0.2535833333333333,0.41952284946236557,2.274448096593221,2.2001695325297694
-2,0.4691875,0.5073084677419355,2.116311640103658,2.051948335862929
-3,0.5270416666666666,0.5266297043010753,2.009436710357666,1.9777893276624783
-4,0.5353541666666667,0.535114247311828,1.9530798486073813,1.9356736265203005
-5,0.5935416666666666,0.6175235215053764,1.9118746633529664,1.891348486305565
-6,0.636625,0.6625504032258065,1.8629151741663614,1.847881397893352
-7,0.686625,0.7302587365591398,1.8228577140172322,1.8057919330494379
-8,0.7415416666666667,0.7511760752688172,1.7803055089314779,1.7647134245082896
-9,0.7542291666666666,0.7582325268817204,1.7502256110509236,1.7423059594246648
-10,0.7607708333333333,0.764616935483871,1.7317150996526083,1.724781782396378
-11,0.7677291666666667,0.7719254032258065,1.7192926041285197,1.713816902970755
-12,0.7704791666666667,0.7731014784946236,1.71117463239034,1.7070557173862253
-13,0.771625,0.7736055107526881,1.7053865385055542,1.7027398668309695
-14,0.7747708333333333,0.7749495967741935,1.7004834445317587,1.6978983327906618
-15,0.7763333333333333,0.7751176075268817,1.6967166414260864,1.6960316857983988
-16,0.7790416666666666,0.7767977150537635,1.6929608987172444,1.692371742699736
-17,0.780125,0.7801579301075269,1.6910814901987712,1.6917471321680213
-18,0.7817916666666667,0.7827620967741935,1.6882368882497152,1.6861866725388395
-19,0.7827291666666667,0.7815860215053764,1.6857908573150635,1.6868788478195027
-20,0.7827083333333333,0.7840221774193549,1.6843910643259685,1.6850647259784002
-21,0.7848541666666666,0.7857862903225806,1.6823169787724812,1.6813292862266622
-22,0.7876666666666666,0.7848622311827957,1.6801685171127319,1.6815461574062225
-23,0.7879791666666667,0.7848622311827957,1.6788572374979656,1.6818229216401295
-24,0.7890833333333334,0.7859543010752689,1.6776897859573365,1.6799169009731663
-25,0.7902708333333334,0.7883904569892473,1.6763870159784953,1.6777271570697907
-26,0.791,0.789986559139785,1.6751194190979004,1.6777111407249206
-27,0.7918541666666666,0.7886424731182796,1.674490571975708,1.6776156912567795
-28,0.7936666666666666,0.7905745967741935,1.6728278172810873,1.6744540147883917
-29,0.793375,0.7876344086021505,1.671903525352478,1.6776354030896259
-30,0.7945833333333333,0.7901545698924731,1.6710031661987306,1.6751063805754467
-31,0.7959166666666667,0.7932627688172043,1.6700964994430543,1.6719800926023913
-32,0.7955833333333333,0.7933467741935484,1.6697869466145834,1.6723043623790945
-33,0.7971458333333333,0.792002688172043,1.668815224647522,1.6722341519530102
-34,0.7974375,0.7931787634408602,1.6682115157445272,1.6723163063808153
-35,0.7979791666666667,0.7947748655913979,1.6676976483662924,1.670254216399244
-36,0.7984583333333334,0.7950268817204301,1.6669070380528768,1.6704239499184392
-37,0.799,0.795866935483871,1.6664897476832072,1.6691849411174815
-38,0.7991875,0.7948588709677419,1.6660230029424032,1.6700230785595473
-39,0.800125,0.795950940860215,1.6655609397888183,1.6688298884258475
-40,0.8006458333333333,0.7956989247311828,1.6652250595092772,1.6690674840763051
-41,0.8006875,0.7962869623655914,1.664971160888672,1.6688041135828982
-42,0.8015416666666667,0.795866935483871,1.6647087678909303,1.668453808753721
-43,0.8013958333333333,0.7962029569892473,1.6643381754557292,1.6682484457569737
-44,0.8016458333333333,0.7965389784946236,1.6641663211186728,1.668392535178892
-45,0.8017708333333333,0.7957829301075269,1.6640429185231527,1.6681856429705055
-46,0.8021041666666666,0.7965389784946236,1.663849822362264,1.6680005634984663
-47,0.8024583333333334,0.7966229838709677,1.663770879427592,1.6679569816076627
-48,0.8025833333333333,0.7962029569892473,1.6636734215418498,1.6680130330465173
-49,0.8024583333333334,0.7970430107526881,1.6635978577931723,1.6679544077124646
-50,0.8025,0.7970430107526881,1.6635685895284016,1.6679527682642783
+,epoch,train_acc,valid_acc,train_loss,valid_loss
+0,1,0.575125,0.7011088709677419,2.031563010215759,1.8535375249001287
+1,2,0.723875,0.7515120967741935,1.7430778923034669,1.713461822079074
+2,3,0.76425,0.7525201612903226,1.6991203842163085,1.7051894049490652
+3,4,0.779875,0.7716733870967742,1.6807003259658813,1.690080665772961
+4,5,0.79525,0.7696572580645161,1.6654855661392212,1.6926762519344207
+5,6,0.80175,0.7888104838709677,1.6598792200088501,1.6711357831954956
+6,7,0.80875,0.7721774193548387,1.6529147624969482,1.6847506146277151
+7,8,0.812375,0.8004032258064516,1.649049828529358,1.6597587523921844
+8,9,0.815375,0.7893145161290323,1.6458229179382324,1.6707303101016628
+9,10,0.825,0.811491935483871,1.6370085287094116,1.6518691432091497
+10,11,0.832375,0.795866935483871,1.630222158432007,1.6616583139665666
+11,12,0.83225,0.8145161290322581,1.6293829317092896,1.6454557026586225
+12,13,0.834875,0.8125,1.6268642024993896,1.6500283018235238
+13,14,0.840875,0.8104838709677419,1.6199358901977539,1.652194688397069
+14,15,0.83975,0.8069556451612904,1.6210605192184449,1.6520756982987927
+15,16,0.84175,0.8004032258064516,1.6195698108673096,1.6582853217278757
+16,17,0.838625,0.8049395161290323,1.6228710346221924,1.656198097813514
+17,18,0.83775,0.8140120967741935,1.6226149969100951,1.6462942131104008
+18,19,0.845375,0.8251008064516129,1.6150365982055663,1.6358921681680987
+19,20,0.85125,0.8296370967741935,1.6097205333709717,1.6333312757553593
+20,21,0.851875,0.8210685483870968,1.609424132347107,1.6388044895664338
+21,22,0.850375,0.8210685483870968,1.6101643466949462,1.6369191561975787
+22,23,0.858125,0.8185483870967742,1.6031983375549317,1.6421872877305554
+23,24,0.857125,0.8361895161290323,1.6038059520721435,1.62519553015309
+24,25,0.854,0.8301411290322581,1.606280044555664,1.6290803609355804
+25,26,0.858375,0.8119959677419355,1.6011180095672608,1.648349738890125
+26,27,0.861375,0.8371975806451613,1.6000273780822754,1.6237776010267195
+27,28,0.8705,0.8351814516129032,1.5907322645187378,1.6240986316434798
+28,29,0.87175,0.828125,1.5896439476013184,1.6316479982868317
+29,30,0.867375,0.8266129032258065,1.5936143741607667,1.632056209348863
+30,31,0.86575,0.8377016129032258,1.5949567575454713,1.6240303862479426
+31,32,0.86975,0.8336693548387096,1.5907692136764526,1.6251203167823054
+32,33,0.86975,0.8397177419354839,1.5919580411911012,1.6214879328204739
+33,34,0.872375,0.8422379032258065,1.5886561880111694,1.6194973222671016
+34,35,0.876,0.8331653225806451,1.585767653465271,1.6247131862948019
+35,36,0.871875,0.8392137096774194,1.5895709590911866,1.6215527211466143
+36,37,0.871125,0.8245967741935484,1.590462643623352,1.6370407227546937
+37,38,0.87325,0.8301411290322581,1.5876847248077393,1.6306157150576193
+38,39,0.8705,0.8240927419354839,1.590844289779663,1.634965923524672
+39,40,0.88125,0.8402217741935484,1.5803495874404907,1.6220719968118975
+40,41,0.881875,0.8462701612903226,1.5788077726364136,1.614263488400367
+41,42,0.87625,0.8487903225806451,1.5843929862976074,1.6131737078389814
+42,43,0.88175,0.842741935483871,1.5789586782455445,1.6184405088424683
+43,44,0.880375,0.8417338709677419,1.5802030544281005,1.6189708786626016
+44,45,0.880375,0.8492943548387096,1.5803771505355835,1.610948174230514
+45,46,0.877625,0.8523185483870968,1.5828620948791503,1.6089561793111986
+46,47,0.882125,0.8442540322580645,1.578727219581604,1.6160847948443504
+47,48,0.872875,0.8392137096774194,1.5874832077026366,1.6228746021947553
+48,49,0.884125,0.8371975806451613,1.5771635084152222,1.6237398655183855
+49,50,0.88975,0.8341733870967742,1.5712118272781372,1.6256768280459988
+50,51,0.876,0.8432459677419355,1.585065812110901,1.6188401445265739
+51,52,0.883,0.844758064516129,1.5785351629257203,1.6169025359615203
+52,53,0.889125,0.8548387096774194,1.5723771095275878,1.607426397262081
+53,54,0.88625,0.8518145161290323,1.5749757404327394,1.6076742141477522
+54,55,0.891125,0.8452620967741935,1.5695797872543336,1.6156867473356185
+55,56,0.891625,0.8497983870967742,1.5691107511520386,1.6118658050414054
+56,57,0.883375,0.8508064516129032,1.577266471862793,1.6087883749315817
+57,58,0.891625,0.8422379032258065,1.5702907581329346,1.6168161553721274
+58,59,0.89375,0.8553427419354839,1.5679762859344482,1.6071604336461713
+59,60,0.885875,0.8482862903225806,1.5749410953521727,1.6108381056016492
+60,61,0.891875,0.8417338709677419,1.5696327953338622,1.6187968907817718
+61,62,0.894,0.8392137096774194,1.5671770153045654,1.6208721822307957
+62,63,0.891125,0.8392137096774194,1.569726734161377,1.6224797733368412
+63,64,0.89325,0.8518145161290323,1.568245210647583,1.606977516605008
+64,65,0.895125,0.8462701612903226,1.5658181638717652,1.6140611633177726
+65,66,0.89175,0.8568548387096774,1.5686321334838866,1.6044510756769488
+66,67,0.896375,0.8412298387096774,1.5650024271011354,1.6208048520549652
+67,68,0.8895,0.8477822580645161,1.571241024017334,1.6136699338113107
+68,69,0.901625,0.8472782258064516,1.5600450325012207,1.612250724146443
+69,70,0.89025,0.8306451612903226,1.5705311574935914,1.630635638390818
+70,71,0.89675,0.8538306451612904,1.5637341051101685,1.6056317244806597
+71,72,0.897,0.8412298387096774,1.5633089447021484,1.6192954970944313
+72,73,0.900375,0.8503024193548387,1.560647201538086,1.6097132775091356
+73,74,0.895625,0.8533266129032258,1.565330421447754,1.6075265484471475
+74,75,0.895125,0.8543346774193549,1.565690894126892,1.6060891266792052
+75,76,0.900625,0.8608870967741935,1.560530616760254,1.6011101891917567
+76,77,0.897125,0.8563508064516129,1.563725378036499,1.6037284789546844
+77,78,0.89175,0.8482862903225806,1.5693257989883422,1.6122698245509979
+78,79,0.90225,0.8487903225806451,1.5589981718063355,1.6111104180735927
+79,80,0.893375,0.8442540322580645,1.5669814805984497,1.6161983090062295
+80,81,0.897125,0.8573588709677419,1.56400607585907,1.6040064134905416
+81,82,0.898,0.8568548387096774,1.5621892538070679,1.6044225615839804
+82,83,0.89075,0.8503024193548387,1.5697740039825439,1.6114465228972896
+83,84,0.900625,0.8598790322580645,1.5606124105453492,1.6002429416102748
+84,85,0.89825,0.8553427419354839,1.5628600664138794,1.603792409743032
diff --git a/data/notebook2/vgg_weights.pt b/data/notebook2/vgg_weights.pt
new file mode 100644
index 0000000..9c08948
Binary files /dev/null and b/data/notebook2/vgg_weights.pt differ