{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.12.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":13836,"databundleVersionId":1718836,"sourceType":"competition"}],"dockerImageVersionId":31236,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Cassava Leaf Disease Classification\n**Assignment Submission**\n\n**Team Members:**\n1. Fares Mahmoud\n2. Youssef Dewidar\n3. Abdelfatah Elsabagh\n\n**Objective:**\nTo classify cassava leaf images into 5 categories.\nWe compare two different techniques:\n1. **Custom CNN (trained from scratch)** as a baseline.\n2. **ResNet50 (Transfer Learning)** for improved accuracy.\n\n**Dataset Split:**\n* **Training:** 70%\n* **Validation:** 20%\n* **Test:** 10%","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"code","source":"# --- DATA SPLITTING (70/20/10) ---\nBASE_DIR = '/kaggle/input/cassava-leaf-disease-classification'\nTRAIN_IMG_PATH = os.path.join(BASE_DIR, 'train_images')\ndf = pd.read_csv(os.path.join(BASE_DIR, 'train.csv'))\n\n# 1. Split 70% Train, 30% Temp\ntrain_df, temp_df = train_test_split(\n df, test_size=0.30, stratify=df['label'], random_state=CONFIG['seed']\n)\n\n# 2. Split Temp into 20% Val and 10% Test\n# (0.3333 of 30% is approx 10%)\nval_df, test_df = train_test_split(\n temp_df, test_size=0.3333, stratify=temp_df['label'], random_state=CONFIG['seed']\n)\n\ntrain_df = train_df.reset_index(drop=True)\nval_df = val_df.reset_index(drop=True)\ntest_df = test_df.reset_index(drop=True)\n\nprint(f\"Train: {len(train_df)} | Val: {len(val_df)} | Test: {len(test_df)}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T08:36:06.670213Z","iopub.execute_input":"2025-12-24T08:36:06.67096Z","iopub.status.idle":"2025-12-24T08:36:06.795548Z","shell.execute_reply.started":"2025-12-24T08:36:06.670931Z","shell.execute_reply":"2025-12-24T08:36:06.795005Z"}},"outputs":[{"name":"stdout","text":"Train: 14977 | Val: 4280 | Test: 2140\n","output_type":"stream"}],"execution_count":4},{"cell_type":"code","source":"import os\nimport random\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport cv2\nfrom tqdm.auto import tqdm\n\n# Scikit-learn\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report, confusion_matrix\n\n# PyTorch\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.nn.functional as F\nfrom torch.utils.data import Dataset, DataLoader\nimport torchvision.transforms as transforms\nfrom torchvision import models\n\n# Albumentations\nimport albumentations as A\nfrom albumentations.pytorch import ToTensorV2\n\nimport warnings\nwarnings.filterwarnings('ignore')\n\n# --- CONFIGURATION ---\nCONFIG = {\n 'seed': 42,\n 'img_size': 224,\n 'batch_size': 64,\n 'epochs': 20,\n 'learning_rate': 1e-4,\n 'num_classes': 5,\n 'device': torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n}\n\ndef seed_everything(seed):\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 torch.backends.cudnn.deterministic = True\n\nseed_everything(CONFIG['seed'])\nprint(f\"Using Device: {CONFIG['device']}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T08:59:23.465171Z","iopub.execute_input":"2025-12-24T08:59:23.465851Z","iopub.status.idle":"2025-12-24T08:59:23.475196Z","shell.execute_reply.started":"2025-12-24T08:59:23.465822Z","shell.execute_reply":"2025-12-24T08:59:23.474571Z"}},"outputs":[{"name":"stdout","text":"Using Device: cuda\n","output_type":"stream"}],"execution_count":10},{"cell_type":"code","source":"# --- DATASET & AUGMENTATIONS ---\nclass CassavaDataset(Dataset):\n def __init__(self, df, img_dir, transforms=None):\n self.df = df\n self.img_dir = img_dir\n self.transforms = transforms\n \n def __len__(self):\n return len(self.df)\n \n def __getitem__(self, index):\n row = self.df.iloc[index]\n img_path = os.path.join(self.img_dir, row['image_id'])\n image = cv2.imread(img_path)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n \n if self.transforms:\n image = self.transforms(image=image)['image']\n \n return image, torch.tensor(row['label'], dtype=torch.long)\n\ntrain_transforms = A.Compose([\n A.Resize(CONFIG['img_size'], CONFIG['img_size']),\n A.HorizontalFlip(p=0.5),\n A.VerticalFlip(p=0.5),\n A.Rotate(limit=30, p=0.5),\n A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n ToTensorV2()\n])\n\nvalid_transforms = A.Compose([\n A.Resize(CONFIG['img_size'], CONFIG['img_size']),\n A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n ToTensorV2()\n])\n\ntrain_ds = CassavaDataset(train_df, TRAIN_IMG_PATH, train_transforms)\nval_ds = CassavaDataset(val_df, TRAIN_IMG_PATH, valid_transforms)\ntest_ds = CassavaDataset(test_df, TRAIN_IMG_PATH, valid_transforms)\n\ntrain_loader = DataLoader(train_ds, batch_size=CONFIG['batch_size'], shuffle=True, num_workers=0)\nval_loader = DataLoader(val_ds, batch_size=CONFIG['batch_size'], shuffle=False, num_workers=0)\ntest_loader = DataLoader(test_ds, batch_size=CONFIG['batch_size'], shuffle=False, num_workers=0)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T08:59:27.882749Z","iopub.execute_input":"2025-12-24T08:59:27.883353Z","iopub.status.idle":"2025-12-24T08:59:27.897416Z","shell.execute_reply.started":"2025-12-24T08:59:27.883323Z","shell.execute_reply":"2025-12-24T08:59:27.896574Z"}},"outputs":[],"execution_count":11},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\n\nclass CBAM(nn.Module):\n def __init__(self, in_planes, ratio=16):\n super(CBAM, self).__init__()\n # Channel Attention\n self.avg_pool = nn.AdaptiveAvgPool2d(1)\n self.max_pool = nn.AdaptiveMaxPool2d(1)\n self.fc = nn.Sequential(\n nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False),\n nn.ReLU(),\n nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)\n )\n # Spatial Attention\n self.sa = nn.Conv2d(2, 1, 7, padding=3, bias=False)\n self.sigmoid = nn.Sigmoid()\n\n def forward(self, x):\n # 1. Channel Attention\n avg_out = self.fc(self.avg_pool(x))\n max_out = self.fc(self.max_pool(x))\n ca = self.sigmoid(avg_out + max_out)\n x = x * ca\n \n # 2. Spatial Attention\n # 修正点：去掉了 .unsqueeze(1)，因为 keepdim=True 已经保留了维度\n avg_mask = torch.mean(x, dim=1, keepdim=True)\n max_mask, _ = torch.max(x, dim=1, keepdim=True)\n \n combined = torch.cat([avg_mask, max_mask], dim=1)\n sa = self.sigmoid(self.sa(combined))\n \n return x * sa\n\n# --- 2. 改进后的主网络 (CNN + CBAM + Transformer) ---\nclass HybridTransformerCNN(nn.Module):\n def __init__(self, num_classes=5, input_res=224):\n super(HybridTransformerCNN, self).__init__()\n \n # 卷积 Block 1-3 (提取基础特征)\n self.layer1 = self._make_layer(3, 32)\n self.cbam1 = CBAM(32)\n \n self.layer2 = self._make_layer(32, 64)\n self.cbam2 = CBAM(64)\n \n self.layer3 = self._make_layer(64, 128)\n self.cbam3 = CBAM(128)\n \n # 卷积 Block 4 (进入深层)\n self.layer4 = self._make_layer(128, 256)\n self.cbam4 = CBAM(256)\n \n # --- Transformer Encoder 模块 ---\n # 此时特征图尺寸为 (Batch, 256, 14, 14)\n self.d_model = 256\n self.num_patches = (input_res // 16) * (input_res // 16) # 14 * 14 = 196\n \n # 位置编码 (Positional Encoding): 让 Transformer 知道像素的位置\n self.pos_embedding = nn.Parameter(torch.randn(1, self.num_patches, self.d_model))\n \n # 定义 Transformer Encoder 层\n # nhead: 多头注意力的头数；dim_feedforward: 内部全连接层维度\n encoder_layer = nn.TransformerEncoderLayer(\n d_model=self.d_model, \n nhead=8, \n dim_feedforward=1024, \n dropout=0.1,\n activation='gelu',\n batch_first=True # 这样输入格式就是 (Batch, Seq, Feature)\n )\n self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=2)\n\n # 分类器\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n self.classifier = nn.Sequential(\n nn.Flatten(),\n nn.Linear(256, 512),\n nn.ReLU(),\n nn.Dropout(0.4),\n nn.Linear(512, num_classes)\n )\n\n def _make_layer(self, in_c, out_c):\n return nn.Sequential(\n nn.Conv2d(in_c, out_c, kernel_size=3, padding=1),\n nn.BatchNorm2d(out_c),\n nn.ReLU(),\n nn.MaxPool2d(2, 2)\n )\n\n def forward(self, x):\n # 1. CNN + CBAM 特征提取\n x = self.cbam1(self.layer1(x))\n x = self.cbam2(self.layer2(x))\n x = self.cbam3(self.layer3(x))\n x = self.cbam4(self.layer4(x)) # 输出: (B, 256, 14, 14)\n\n # 2. 准备进入 Transformer\n # B, C, H, W -> B, (H*W), C\n B, C, H, W = x.shape\n x = x.flatten(2).transpose(1, 2) \n \n # 加入位置编码\n x = x + self.pos_embedding\n \n # 3. Transformer Encoder 全局建模\n x = self.transformer_encoder(x) # 输出: (B, 196, 256)\n \n # 4. 还原回 CNN 形状进行池化 (或者直接对 Token 求均值)\n # 还原: B, 196, 256 -> B, 256, 14, 14\n x = x.transpose(1, 2).reshape(B, C, H, W)\n \n # 5. 分类\n x = self.avgpool(x)\n x = self.classifier(x)\n return x\n\n# 测试模型\n# model = HybridTransformerCNN(num_classes=5)\n# print(model(torch.randn(1, 3, 224, 224)).shape)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T09:05:50.844054Z","iopub.execute_input":"2025-12-24T09:05:50.844713Z","iopub.status.idle":"2025-12-24T09:05:50.856666Z","shell.execute_reply.started":"2025-12-24T09:05:50.844685Z","shell.execute_reply":"2025-12-24T09:05:50.855987Z"}},"outputs":[],"execution_count":17},{"cell_type":"markdown","source":"## Technique 1: Custom CNN (From Scratch)\nWe build a simple Convolutional Neural Network with 4 convolutional blocks. This serves as our baseline experiment.","metadata":{}},{"cell_type":"code","source":"class CustomCNN(nn.Module):\n def __init__(self, num_classes=5):\n super(CustomCNN, self).__init__()\n # 4 Convolutional Blocks\n self.features = nn.Sequential(\n # Block 1\n nn.Conv2d(3, 32, kernel_size=3, padding=1),\n nn.BatchNorm2d(32),\n nn.ReLU(),\n nn.MaxPool2d(2, 2), # 112x112\n \n # Block 2\n nn.Conv2d(32, 64, kernel_size=3, padding=1),\n nn.BatchNorm2d(64),\n nn.ReLU(),\n nn.MaxPool2d(2, 2), # 56x56\n \n # Block 3\n nn.Conv2d(64, 128, kernel_size=3, padding=1),\n nn.BatchNorm2d(128),\n nn.ReLU(),\n nn.MaxPool2d(2, 2), # 28x28\n \n # Block 4\n nn.Conv2d(128, 256, kernel_size=3, padding=1),\n nn.BatchNorm2d(256),\n nn.ReLU(),\n nn.MaxPool2d(2, 2), # 14x14\n )\n \n self.classifier = nn.Sequential(\n nn.Flatten(),\n nn.Dropout(0.5),\n nn.Linear(256 * 14 * 14, 512),\n nn.ReLU(),\n nn.Dropout(0.3),\n nn.Linear(512, num_classes)\n )\n\n def forward(self, x):\n x = self.features(x)\n x = self.classifier(x)\n return x","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T08:59:38.892617Z","iopub.execute_input":"2025-12-24T08:59:38.893232Z","iopub.status.idle":"2025-12-24T08:59:38.899431Z","shell.execute_reply.started":"2025-12-24T08:59:38.893208Z","shell.execute_reply":"2025-12-24T08:59:38.898921Z"}},"outputs":[],"execution_count":13},{"cell_type":"markdown","source":"## Technique 2: Transfer Learning (ResNet50)\nWe use a ResNet50 model pre-trained on ImageNet. This typically performs better as it has already learned feature extraction from millions of images.","metadata":{}},{"cell_type":"code","source":"class ResNetTransfer(nn.Module):\n def __init__(self, num_classes=5):\n super(ResNetTransfer, self).__init__()\n self.backbone = models.resnet50(pretrained=True)\n \n # Replace FC layer\n in_features = self.backbone.fc.in_features\n self.backbone.fc = nn.Sequential(\n nn.Linear(in_features, 512),\n nn.ReLU(),\n nn.Dropout(0.3),\n nn.Linear(512, num_classes)\n )\n \n def forward(self, x):\n return self.backbone(x)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T08:59:42.080817Z","iopub.execute_input":"2025-12-24T08:59:42.081515Z","iopub.status.idle":"2025-12-24T08:59:42.086098Z","shell.execute_reply.started":"2025-12-24T08:59:42.081489Z","shell.execute_reply":"2025-12-24T08:59:42.085306Z"}},"outputs":[],"execution_count":14},{"cell_type":"code","source":"# --- UNIVERSAL TRAINING FUNCTION ---\ndef train_model(model_class, model_name, epochs=8):\n print(f\"\\n🚀 STARTING TRAINING: {model_name}\")\n print(\"=\"*40)\n \n model = model_class(num_classes=5).to(CONFIG['device'])\n criterion = nn.CrossEntropyLoss()\n optimizer = optim.Adam(model.parameters(), lr=CONFIG['learning_rate'])\n \n best_acc = 0.0\n history = {'train_acc': [], 'val_acc': []}\n \n for epoch in range(epochs):\n # Train\n model.train()\n train_correct = 0\n train_total = 0\n \n for images, labels in tqdm(train_loader, desc=f\"Epoch {epoch+1}\", leave=False):\n images, labels = images.to(CONFIG['device']), labels.to(CONFIG['device'])\n print('shape',images)\n optimizer.zero_grad()\n outputs = model(images)\n loss = criterion(outputs, labels)\n loss.backward()\n optimizer.step()\n \n _, preds = outputs.max(1)\n train_correct += (preds == labels).sum().item()\n train_total += labels.size(0)\n \n train_acc = 100. * train_correct / train_total\n \n # Validate\n model.eval()\n val_correct = 0\n val_total = 0\n with torch.no_grad():\n for images, labels in val_loader:\n images, labels = images.to(CONFIG['device']), labels.to(CONFIG['device'])\n outputs = model(images)\n _, preds = outputs.max(1)\n val_correct += (preds == labels).sum().item()\n val_total += labels.size(0)\n \n val_acc = 100. * val_correct / val_total\n \n print(f\"Epoch {epoch+1} | Train Acc: {train_acc:.2f}% | Val Acc: {val_acc:.2f}%\")\n \n history['train_acc'].append(train_acc)\n history['val_acc'].append(val_acc)\n \n if val_acc > best_acc:\n best_acc = val_acc\n torch.save(model.state_dict(), f'best_{model_name}.pth')\n \n return history, best_acc\n\n# 1. Train Custom CNN\nhist_custom, acc_custom = train_model(CustomCNN, \"CustomCNN\", epochs=10)\nhist_Transformer, acc_Transformer = train_model(HybridTransformerCNN, \"HybridTransformerCNN\", epochs=20)\n# 2. Train ResNet50\nhist_resnet, acc_resnet = train_model(ResNetTransfer, \"ResNet50\", epochs=8)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-25T02:07:40.069751Z","iopub.execute_input":"2025-12-25T02:07:40.070026Z","iopub.status.idle":"2025-12-25T02:07:40.094166Z","shell.execute_reply.started":"2025-12-25T02:07:40.069991Z","shell.execute_reply":"2025-12-25T02:07:40.093172Z"}},"outputs":[{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_55/749404681.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[0;31m# 1. Train Custom CNN\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 60\u001b[0;31m \u001b[0mhist_custom\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0macc_custom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mCustomCNN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"CustomCNN\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 61\u001b[0m \u001b[0mhist_Transformer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0macc_Transformer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mHybridTransformerCNN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"HybridTransformerCNN\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0;31m# 2. Train ResNet50\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mNameError\u001b[0m: name 'CustomCNN' is not defined"],"ename":"NameError","evalue":"name 'CustomCNN' is not defined","output_type":"error"}],"execution_count":1},{"cell_type":"code","source":"# --- COMPARISON & RESULTS ---\n\nprint(\"\\n🏆 FINAL COMPARISON\")\nprint(\"=\"*40)\nprint(f\"1. acc_Transformer Validation Accuracy: {acc_Transformer:.2f}%\")\nprint(f\"2. ResNet50 Validation Accuracy: {acc_resnet:.2f}%\")\n\n# Plotting Comparison\nplt.figure(figsize=(10, 5))\nplt.plot(hist_custom['val_acc'], label=f'Custom CNN (Best: {acc_Transformer:.1f}%)', marker='o')\nplt.plot(hist_resnet['val_acc'], label=f'ResNet50 (Best: {acc_resnet:.1f}%)', marker='o')\nplt.title('Validation Accuracy Comparison')\nplt.xlabel('Epochs')\nplt.ylabel('Accuracy %')\nplt.legend()\nplt.grid(True)\nplt.show()\n\n# --- FINAL TEST EVALUATION (Using the better model) ---\nprint(\"\\n📝 Evaluating Best Model on Test Set (10% split)...\")\n# best_model_name = \"ResNet50\" if acc_resnet > acc_custom else \"CustomCNN\"\n# model_class = ResNetTransfer if acc_resnet > acc_custom else CustomCNN\nbest_model_name = \"HybridTransformerCNN\"\nmodel_class = HybridTransformerCNN\nfinal_model = model_class().to(CONFIG['device'])\nfinal_model.load_state_dict(torch.load(f'best_{best_model_name}.pth'))\nfinal_model.eval()\n\nall_preds = []\nall_labels = []\n\nwith torch.no_grad():\n for images, labels in test_loader:\n images = images.to(CONFIG['device'])\n outputs = final_model(images)\n _, preds = outputs.max(1)\n all_preds.extend(preds.cpu().numpy())\n all_labels.extend(labels.cpu().numpy())\n\nprint(f\"Selected Model: {best_model_name}\")\nprint(classification_report(all_labels, all_preds))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T14:03:42.017956Z","iopub.execute_input":"2025-12-24T14:03:42.018509Z","iopub.status.idle":"2025-12-24T14:04:01.547896Z","shell.execute_reply.started":"2025-12-24T14:03:42.01848Z","shell.execute_reply":"2025-12-24T14:04:01.547155Z"}},"outputs":[{"name":"stdout","text":"\n🏆 FINAL COMPARISON\n========================================\n1. acc_Transformer Validation Accuracy: 77.71%\n2. ResNet50 Validation Accuracy: 85.65%\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}},{"name":"stdout","text":"\n📝 Evaluating Best Model on Test Set (10% split)...\nSelected Model: HybridTransformerCNN\n precision recall f1-score support\n\n 0 0.42 0.51 0.46 109\n 1 0.67 0.56 0.61 219\n 2 0.57 0.56 0.56 239\n 3 0.93 0.90 0.91 1316\n 4 0.50 0.61 0.55 257\n\n accuracy 0.77 2140\n macro avg 0.62 0.63 0.62 2140\nweighted avg 0.78 0.77 0.78 2140\n\n","output_type":"stream"}],"execution_count":26},{"cell_type":"code","source":"# --- COMPARISON & RESULTS ---\n\nprint(\"\\n🏆 FINAL COMPARISON OF THREE MODELS\")\nprint(\"=\"*50)\nprint(f\"1. Custom CNN Accuracy: {acc_custom:.2f}%\")\nprint(f\"2. Hybrid Transformer Accuracy: {acc_Transformer:.2f}%\")\nprint(f\"3. ResNet50 Accuracy: {acc_resnet:.2f}%\")\nprint(\"=\"*50)\n\n# 绘制对比曲线\nplt.figure(figsize=(12, 6))\n\n# 曲线 1: Custom CNN\nplt.plot(hist_custom['val_acc'], label=f'Custom CNN (Best: {acc_custom:.1f}%)', color='gray', linestyle='--', marker='s')\n\n# 曲线 2: Hybrid Transformer CNN\nplt.plot(hist_trans['val_acc'], label=f'Hybrid Transformer (Best: {acc_trans:.1f}%)', color='blue', marker='o')\n\n# 曲线 3: ResNet50\nplt.plot(hist_resnet['val_acc'], label=f'ResNet50 (Best: {acc_resnet:.1f}%)', color='red', marker='x')\n\nplt.title('Validation Accuracy Comparison: CNN vs Hybrid vs ResNet', fontsize=14)\nplt.xlabel('Epochs')\nplt.ylabel('Accuracy %')\nplt.legend()\nplt.grid(True, alpha=0.3)\nplt.tight_layout()\nplt.show()\n\n# --- 自动选择并加载表现最好的模型进行最终测试 ---\n\n# 创建一个字典来查找最佳模型\nresults = {\n \"CustomCNN\": {\"acc\": acc_custom, \"class\": CustomCNN},\n \"HybridTransformerCNN\": {\"acc\": acc_trans, \"class\": HybridTransformerCNN},\n \"ResNet50\": {\"acc\": acc_resnet, \"class\": ResNetTransfer}\n}\n\n# 找到准确率最高的名字\nbest_model_name = max(results, key=lambda x: results[x][\"acc\"])\nbest_model_class = results[best_model_name][\"class\"]\n\nprint(f\"\\n📝 Evaluating THE BEST model on Test Set: {best_model_name}...\")\n\n# 实例化并加载权重\nfinal_model = best_model_class(num_classes=5).to(CONFIG['device'])\nfinal_model.load_state_dict(torch.load(f'best_{best_model_name}.pth'))\nfinal_model.eval()\n\nall_preds = []\nall_labels = []\n\nwith torch.no_grad():\n for images, labels in test_loader:\n images = images.to(CONFIG['device'])\n outputs = final_model(images)\n _, preds = outputs.max(1)\n all_preds.extend(preds.cpu().numpy())\n all_labels.extend(labels.cpu().numpy())\n\nprint(f\"\\n✅ Final Report for {best_model_name}:\")\nprint(classification_report(all_labels, all_preds))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T14:07:38.22841Z","iopub.execute_input":"2025-12-24T14:07:38.228745Z","iopub.status.idle":"2025-12-24T14:07:38.366658Z","shell.execute_reply.started":"2025-12-24T14:07:38.228719Z","shell.execute_reply":"2025-12-24T14:07:38.365893Z"}},"outputs":[{"name":"stdout","text":"\n🏆 FINAL COMPARISON OF THREE MODELS\n==================================================\n1. Custom CNN Accuracy: 71.14%\n2. Hybrid Transformer Accuracy: 77.71%\n3. ResNet50 Accuracy: 85.65%\n==================================================\n","output_type":"stream"},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_55/966686168.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;31m# 曲线 2: Hybrid Transformer CNN\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhist_trans\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'val_acc'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34mf'Hybrid Transformer (Best: {acc_trans:.1f}%)'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'blue'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'o'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;31m# 曲线 3: ResNet50\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mNameError\u001b[0m: name 'hist_trans' is not defined"],"ename":"NameError","evalue":"name 'hist_trans' is not defined","output_type":"error"},{"output_type":"display_data","data":{"text/plain":"
","image/png":"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\n"},"metadata":{}}],"execution_count":29},{"cell_type":"code","source":"# --- KAGGLE SUBMISSION ---\nimport glob\n\ndef predict_image(image_path, model, transform):\n image = cv2.imread(image_path)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n \n # Apply the same validation transforms\n if transform:\n augmented = transform(image=image)\n image = augmented['image']\n \n # Add batch dimension (3, 224, 224) -> (1, 3, 224, 224)\n image = image.unsqueeze(0).to(CONFIG['device'])\n \n with torch.no_grad():\n output = model(image)\n _, predicted = torch.max(output, 1)\n \n return predicted.item()\n\n# Load Test Images (Kaggle Evaluation Images)\ntest_files = glob.glob(os.path.join(BASE_DIR, 'test_images', '*.jpg'))\nsubmission = {'image_id': [], 'label': []}\n\nprint(f\"📝 Generating predictions for {len(test_files)} images...\")\n\n# 3. Predict Loop\nfor img_path in test_files:\n img_id = os.path.basename(img_path)\n pred_label = predict_image(img_path, final_model, valid_transforms)\n \n submission['image_id'].append(img_id)\n submission['label'].append(pred_label)\n\n# 4. Save CSV\nsub_df = pd.DataFrame(submission)\nsub_df.to_csv('submission.csv', index=False)\n\nprint(\"✅ 'submission.csv' saved!\")\nprint(sub_df.head())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-12-24T10:59:41.591501Z","iopub.execute_input":"2025-12-24T10:59:41.591773Z","iopub.status.idle":"2025-12-24T10:59:41.639911Z","shell.execute_reply.started":"2025-12-24T10:59:41.591751Z","shell.execute_reply":"2025-12-24T10:59:41.639282Z"}},"outputs":[{"name":"stdout","text":"📝 Generating predictions for 1 images...\n✅ 'submission.csv' saved!\n image_id label\n0 2216849948.jpg 2\n","output_type":"stream"}],"execution_count":23}]}