commit first

Code.ipynb

@@ -0,0 +1,551 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44173db3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model 1 test trên train Kaggle2:\n",
+      "Accuracy: 0.9222, Precision: 0.9202, Recall: 0.9245, F1: 0.9224\n",
+      "Model 2 test trên train Kaggle1:\n",
+      "Accuracy: 0.9164, Precision: 0.9220, Recall: 0.9098, F1: 0.9159\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import datasets, transforms, models\n",
+    "from torch.utils.data import DataLoader\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
+    "import numpy as np\n",
+    "\n",
+    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+    "BATCH_SIZE = 32\n",
+    "NUM_CLASSES = 2\n",
+    "\n",
+    "def get_loader(data_root):\n",
+    "    transform = transforms.Compose([\n",
+    "        transforms.Resize((224, 224)),\n",
+    "        transforms.ToTensor(),\n",
+    "    ])\n",
+    "    dataset = datasets.ImageFolder(data_root, transform=transform)\n",
+    "    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=4)\n",
+    "    return loader\n",
+    "\n",
+    "def load_model(weight_path):\n",
+    "    model = models.efficientnet_b0(weights=None)\n",
+    "    model.classifier[1] = nn.Linear(model.classifier[1].in_features, NUM_CLASSES)\n",
+    "    model.load_state_dict(torch.load(weight_path, map_location=DEVICE))\n",
+    "    model = model.to(DEVICE)\n",
+    "    model.eval()\n",
+    "    return model\n",
+    "\n",
+    "def evaluate(model, loader):\n",
+    "    all_labels = []\n",
+    "    all_preds = []\n",
+    "    with torch.no_grad():\n",
+    "        for imgs, labels in loader:\n",
+    "            imgs = imgs.to(DEVICE)\n",
+    "            outputs = model(imgs)\n",
+    "            preds = torch.argmax(outputs, dim=1).cpu().numpy()\n",
+    "            all_preds.extend(preds)\n",
+    "            all_labels.extend(labels.numpy())\n",
+    "    acc = accuracy_score(all_labels, all_preds)\n",
+    "    prec = precision_score(all_labels, all_preds, zero_division=0)\n",
+    "    rec = recall_score(all_labels, all_preds, zero_division=0)\n",
+    "    f1 = f1_score(all_labels, all_preds, zero_division=0)\n",
+    "    return acc, prec, rec, f1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "faf9e19b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model 1 test trên train Kaggle2:\n",
+      "Accuracy: 0.9300, Precision: 0.9555, Recall: 0.9020, F1: 0.9280\n",
+      "Model 2 test trên train Kaggle1:\n",
+      "Accuracy: 0.9200, Precision: 0.9430, Recall: 0.8940, F1: 0.9179\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Đường dẫn model và data\n",
+    "model1_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle1.pth'\n",
+    "model2_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle2.pth'\n",
+    "data1_train = '/home/ubuntu/vnet/TaoST/Data10kKaggle2/test'\n",
+    "data2_train = '/home/ubuntu/vnet/TaoST/Data10kKaggle1/test'\n",
+    "# Test chéo\n",
+    "model1 = load_model(model1_path)\n",
+    "model2 = load_model(model2_path)\n",
+    "\n",
+    "loader1 = get_loader(data1_train)\n",
+    "loader2 = get_loader(data2_train)\n",
+    "\n",
+    "print(\"Model 1 test trên train Kaggle2:\")\n",
+    "acc, prec, rec, f1 = evaluate(model1, loader2)\n",
+    "print(f\"Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")\n",
+    "\n",
+    "print(\"Model 2 test trên train Kaggle1:\")\n",
+    "acc, prec, rec, f1 = evaluate(model2, loader1)\n",
+    "print(f\"Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3737fe93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model 1 test trên train Kaggle2:\n",
+      "Accuracy: 0.9300, Precision: 0.9555, Recall: 0.9020, F1: 0.9280\n",
+      "Model 2 test trên train Kaggle1:\n",
+      "Accuracy: 0.9200, Precision: 0.9430, Recall: 0.8940, F1: 0.9179\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Đường dẫn model và data\n",
+    "model1_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle1.pth'\n",
+    "model2_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle2.pth'\n",
+    "data1_train = '/home/ubuntu/vnet/TaoST/Data10kKaggle2/test'\n",
+    "data2_train = '/home/ubuntu/vnet/TaoST/Data10kKaggle1/test'\n",
+    "# Test chéo\n",
+    "model1 = load_model(model1_path)\n",
+    "model2 = load_model(model2_path)\n",
+    "\n",
+    "loader1 = get_loader(data1_train)\n",
+    "loader2 = get_loader(data2_train)\n",
+    "\n",
+    "print(\"Model 1 test trên train Kaggle2:\")\n",
+    "acc, prec, rec, f1 = evaluate(model1, loader2)\n",
+    "print(f\"Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")\n",
+    "\n",
+    "print(\"Model 2 test trên train Kaggle1:\")\n",
+    "acc, prec, rec, f1 = evaluate(model2, loader1)\n",
+    "print(f\"Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "45ff1792",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ensemble (Averaging) trên test: Accuracy: 0.9240, Precision: 0.9511, Recall: 0.8940, F1: 0.9216\n"
+     ]
+    }
+   ],
+   "source": [
+    "def ensemble_average_predict(model1, model2, loader):\n",
+    "    all_labels = []\n",
+    "    all_preds = []\n",
+    "    model1.eval()\n",
+    "    model2.eval()\n",
+    "    with torch.no_grad():\n",
+    "        for imgs, labels in loader:\n",
+    "            imgs = imgs.to(DEVICE)\n",
+    "            out1 = torch.softmax(model1(imgs), dim=1)\n",
+    "            out2 = torch.softmax(model2(imgs), dim=1)\n",
+    "            avg_out = (out1 + out2) / 2\n",
+    "            preds = torch.argmax(avg_out, dim=1).cpu().numpy()\n",
+    "            all_preds.extend(preds)\n",
+    "            all_labels.extend(labels.numpy())\n",
+    "    acc = accuracy_score(all_labels, all_preds)\n",
+    "    prec = precision_score(all_labels, all_preds, zero_division=0)\n",
+    "    rec = recall_score(all_labels, all_preds, zero_division=0)\n",
+    "    f1 = f1_score(all_labels, all_preds, zero_division=0)\n",
+    "    return acc, prec, rec, f1\n",
+    "\n",
+    "# Đường dẫn model và data test\n",
+    "model1_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle1.pth'\n",
+    "model2_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle2.pth'\n",
+    "data_test = '/home/ubuntu/vnet/TaoST/Data10kKaggle1/test'  # hoặc Data10kKaggle2/test\n",
+    "\n",
+    "model1 = load_model(model1_path)\n",
+    "model2 = load_model(model2_path)\n",
+    "loader = get_loader(data_test)\n",
+    "\n",
+    "acc, prec, rec, f1 = ensemble_average_predict(model1, model2, loader)\n",
+    "print(f\"Ensemble (Averaging) trên test: Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a82b49da",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/5, Loss: 0.0806\n",
+      "Epoch 2/5, Loss: 0.0598\n",
+      "Epoch 3/5, Loss: 0.0542\n",
+      "Epoch 4/5, Loss: 0.0444\n",
+      "Epoch 5/5, Loss: 0.0394\n",
+      "GAT Ensemble trên test: Accuracy: 0.9210, Precision: 0.9647, Recall: 0.8740, F1: 0.9171\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import models, transforms, datasets\n",
+    "from torch.utils.data import DataLoader\n",
+    "import torch.nn.functional as F\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
+    "\n",
+    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+    "NUM_CLASSES = 2\n",
+    "BATCH_SIZE = 32\n",
+    "EPOCHS = 5\n",
+    "\n",
+    "class SimpleGATLayer(nn.Module):\n",
+    "    def __init__(self, in_features, out_features):\n",
+    "        super().__init__()\n",
+    "        self.fc = nn.Linear(in_features, out_features)\n",
+    "        self.attn = nn.Parameter(torch.Tensor(1, out_features))\n",
+    "        nn.init.xavier_uniform_(self.attn.data, gain=1.414)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        h = self.fc(x)\n",
+    "        attn_score = torch.matmul(h, self.attn.t())\n",
+    "        attn_score = F.softmax(attn_score, dim=1)\n",
+    "        h_prime = (attn_score * h).sum(dim=1)\n",
+    "        return h_prime\n",
+    "\n",
+    "class GATEnsembleClassifier(nn.Module):\n",
+    "    def __init__(self, feature_dim, num_classes):\n",
+    "        super().__init__()\n",
+    "        self.gat = SimpleGATLayer(feature_dim, feature_dim)\n",
+    "        self.classifier = nn.Linear(feature_dim, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        h = self.gat(x)\n",
+    "        out = self.classifier(h)\n",
+    "        return out\n",
+    "\n",
+    "def get_feature_extractor(weight_path):\n",
+    "    model = models.efficientnet_b0(weights=None)\n",
+    "    model.classifier[1] = nn.Linear(model.classifier[1].in_features, 2)\n",
+    "    model.load_state_dict(torch.load(weight_path, map_location=DEVICE))\n",
+    "    backbone = nn.Sequential(*(list(model.children())[:-1]))\n",
+    "    backbone.eval()\n",
+    "    return backbone.to(DEVICE)\n",
+    "\n",
+    "def get_loader(data_root, split):\n",
+    "    transform = transforms.Compose([\n",
+    "        transforms.Resize((224, 224)),\n",
+    "        transforms.ToTensor(),\n",
+    "    ])\n",
+    "    dataset = datasets.ImageFolder(f\"{data_root}/{split}\", transform=transform)\n",
+    "    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)\n",
+    "    return loader\n",
+    "\n",
+    "# Đường dẫn model và data\n",
+    "model1_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle1.pth'\n",
+    "model2_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle2.pth'\n",
+    "data_root = '/home/ubuntu/vnet/TaoST/Data10kKaggle'\n",
+    "\n",
+    "# Load feature extractors (freeze)\n",
+    "fe1 = get_feature_extractor(model1_path)\n",
+    "fe2 = get_feature_extractor(model2_path)\n",
+    "for p in fe1.parameters():\n",
+    "    p.requires_grad = False\n",
+    "for p in fe2.parameters():\n",
+    "    p.requires_grad = False\n",
+    "\n",
+    "feature_dim = 1280\n",
+    "gat_ensemble = GATEnsembleClassifier(feature_dim, NUM_CLASSES).to(DEVICE)\n",
+    "\n",
+    "optimizer = torch.optim.Adam(gat_ensemble.parameters(), lr=1e-3)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "train_loader = get_loader(data_root, 'train')\n",
+    "val_loader = get_loader(data_root, 'test')\n",
+    "\n",
+    "# Huấn luyện GAT ensemble\n",
+    "for epoch in range(EPOCHS):\n",
+    "    gat_ensemble.train()\n",
+    "    running_loss = 0.0\n",
+    "    for imgs, labels in train_loader:\n",
+    "        imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)\n",
+    "        with torch.no_grad():\n",
+    "            f1 = fe1(imgs).squeeze(-1).squeeze(-1)\n",
+    "            f2 = fe2(imgs).squeeze(-1).squeeze(-1)\n",
+    "            features = torch.stack([f1, f2], dim=1)\n",
+    "        outputs = gat_ensemble(features)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        running_loss += loss.item() * imgs.size(0)\n",
+    "    print(f\"Epoch {epoch+1}/{EPOCHS}, Loss: {running_loss/len(train_loader.dataset):.4f}\")\n",
+    "\n",
+    "# Đánh giá trên tập test\n",
+    "gat_ensemble.eval()\n",
+    "all_labels = []\n",
+    "all_preds = []\n",
+    "with torch.no_grad():\n",
+    "    for imgs, labels in val_loader:\n",
+    "        imgs = imgs.to(DEVICE)\n",
+    "        f1 = fe1(imgs).squeeze(-1).squeeze(-1)\n",
+    "        f2 = fe2(imgs).squeeze(-1).squeeze(-1)\n",
+    "        features = torch.stack([f1, f2], dim=1)\n",
+    "        outputs = gat_ensemble(features)\n",
+    "        preds = torch.argmax(outputs, dim=1).cpu().numpy()\n",
+    "        all_preds.extend(preds)\n",
+    "        all_labels.extend(labels.numpy())\n",
+    "\n",
+    "acc = accuracy_score(all_labels, all_preds)\n",
+    "prec = precision_score(all_labels, all_preds, zero_division=0)\n",
+    "rec = recall_score(all_labels, all_preds, zero_division=0)\n",
+    "f1 = f1_score(all_labels, all_preds, zero_division=0)\n",
+    "print(f\"GAT Ensemble trên test: Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")\n",
+    "\n",
+    "# Lưu lại model GAT nếu muốn\n",
+    "torch.save(gat_ensemble.state_dict(), '/home/ubuntu/vnet/FL/gat_ensemble_kaggle.pth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "70f1fdff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Khởi tạo feature extractor và biến feature_dim\n",
+    "model1_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle1.pth'\n",
+    "model2_path = '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle2.pth'\n",
+    "def get_feature_extractor(weight_path):\n",
+    "    model = models.efficientnet_b0(weights=None)\n",
+    "    model.classifier[1] = nn.Linear(model.classifier[1].in_features, 2)\n",
+    "    model.load_state_dict(torch.load(weight_path, map_location=DEVICE))\n",
+    "    backbone = nn.Sequential(*(list(model.children())[:-1]))\n",
+    "    backbone.eval()\n",
+    "    return backbone.to(DEVICE)\n",
+    "fe1 = get_feature_extractor(model1_path)\n",
+    "fe2 = get_feature_extractor(model2_path)\n",
+    "feature_dim = 1280"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "24525bd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "GAT Ensemble trên train: Accuracy: 0.9210, Precision: 0.9647, Recall: 0.8740, F1: 0.9171\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Đảm bảo fe1, fe2, feature_dim đã được load như sau:\n",
+    "# fe1 = get_feature_extractor(model1_path)\n",
+    "# fe2 = get_feature_extractor(model2_path)\n",
+    "# feature_dim = 1280\n",
+    "\n",
+    "gat_ensemble = GATEnsembleClassifier(feature_dim, NUM_CLASSES).to(DEVICE)\n",
+    "gat_ensemble.load_state_dict(torch.load('/home/ubuntu/vnet/FL/gat_ensemble_kaggle.pth', map_location=DEVICE))\n",
+    "gat_ensemble.eval()\n",
+    "\n",
+    "train_loader = get_loader('/home/ubuntu/vnet/TaoST/Data10kKaggle', 'test')\n",
+    "\n",
+    "all_labels = []\n",
+    "all_preds = []\n",
+    "with torch.no_grad():\n",
+    "    for imgs, labels in train_loader:\n",
+    "        imgs = imgs.to(DEVICE)\n",
+    "        f1 = fe1(imgs).squeeze(-1).squeeze(-1)\n",
+    "        f2 = fe2(imgs).squeeze(-1).squeeze(-1)\n",
+    "        features = torch.stack([f1, f2], dim=1)\n",
+    "        outputs = gat_ensemble(features)\n",
+    "        preds = torch.argmax(outputs, dim=1).cpu().numpy()\n",
+    "        all_preds.extend(preds)\n",
+    "        all_labels.extend(labels.numpy())\n",
+    "\n",
+    "acc = accuracy_score(all_labels, all_preds)\n",
+    "prec = precision_score(all_labels, all_preds, zero_division=0)\n",
+    "rec = recall_score(all_labels, all_preds, zero_division=0)\n",
+    "f1 = f1_score(all_labels, all_preds, zero_division=0)\n",
+    "print(f\"GAT Ensemble trên train: Accuracy: {acc:.4f}, Precision: {prec:.4f}, Recall: {rec:.4f}, F1: {f1:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3a5385c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Exported to /home/ubuntu/vnet/FL/gat_ensemble_kaggle.onnx\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "\n",
+    "# Định nghĩa lại lớp GATEnsembleClassifier và SimpleGATLayer\n",
+    "class SimpleGATLayer(nn.Module):\n",
+    "    def __init__(self, in_features, out_features):\n",
+    "        super().__init__()\n",
+    "        self.fc = nn.Linear(in_features, out_features)\n",
+    "        self.attn = nn.Parameter(torch.Tensor(1, out_features))\n",
+    "        nn.init.xavier_uniform_(self.attn.data, gain=1.414)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        h = self.fc(x)\n",
+    "        attn_score = torch.matmul(h, self.attn.t())\n",
+    "        attn_score = torch.softmax(attn_score, dim=1)\n",
+    "        h_prime = (attn_score * h).sum(dim=1)\n",
+    "        return h_prime\n",
+    "\n",
+    "class GATEnsembleClassifier(nn.Module):\n",
+    "    def __init__(self, feature_dim, num_classes):\n",
+    "        super().__init__()\n",
+    "        self.gat = SimpleGATLayer(feature_dim, feature_dim)\n",
+    "        self.classifier = nn.Linear(feature_dim, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        h = self.gat(x)\n",
+    "        out = self.classifier(h)\n",
+    "        return out\n",
+    "\n",
+    "# Thông số\n",
+    "feature_dim = 1280\n",
+    "num_classes = 2\n",
+    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+    "\n",
+    "# Khởi tạo và load trọng số\n",
+    "model = GATEnsembleClassifier(feature_dim, num_classes).to(DEVICE)\n",
+    "model.load_state_dict(torch.load('/home/ubuntu/vnet/FL/gat_ensemble_kaggle.pth', map_location=DEVICE))\n",
+    "model.eval()\n",
+    "\n",
+    "# Dummy input: batch_size=1, num_models=2, feature_dim=1280\n",
+    "dummy_input = torch.randn(1, 2, feature_dim).to(DEVICE)\n",
+    "\n",
+    "# Export sang ONNX\n",
+    "torch.onnx.export(\n",
+    "    model,\n",
+    "    dummy_input,\n",
+    "    \"/home/ubuntu/vnet/FL/gat_ensemble_kaggle.onnx\",\n",
+    "    input_names=[\"features\"],\n",
+    "    output_names=[\"output\"],\n",
+    "    dynamic_axes={\"features\": {0: \"batch_size\"}},\n",
+    "    opset_version=12\n",
+    ")\n",
+    "\n",
+    "print(\"Exported to /home/ubuntu/vnet/FL/gat_ensemble_kaggle.onnx\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2475f009",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'onnxruntime'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01monnxruntime\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mort\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtorchvision\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m transforms\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mPIL\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Image\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'onnxruntime'"
+     ]
+    }
+   ],
+   "source": [
+    "import onnxruntime as ort\n",
+    "from torchvision import transforms\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import os\n",
+    "\n",
+    "# Đường dẫn ONNX model\n",
+    "onnx_path = \"/home/ubuntu/vnet/FL/gat_ensemble_kaggle.onnx\"\n",
+    "session = ort.InferenceSession(onnx_path, providers=['CPUExecutionProvider'])\n",
+    "\n",
+    "# Chuẩn bị transform giống như khi train\n",
+    "transform = transforms.Compose([\n",
+    "    transforms.Resize((224, 224)),\n",
+    "    transforms.ToTensor(),\n",
+    "])\n",
+    "\n",
+    "# Lấy batch ảnh từ folder benign\n",
+    "folder = \"/home/ubuntu/vnet/TaoST/Data10kKaggle1/test/benign\"\n",
+    "image_files = [os.path.join(folder, f) for f in os.listdir(folder) if f.endswith(('.jpg', '.png', '.jpeg'))]\n",
+    "batch_size = min(4, len(image_files))  # ví dụ lấy 4 ảnh\n",
+    "images = []\n",
+    "for img_path in image_files[:batch_size]:\n",
+    "    img = Image.open(img_path).convert('RGB')\n",
+    "    img = transform(img)\n",
+    "    images.append(img)\n",
+    "batch_tensor = torch.stack(images)  # [batch, 3, 224, 224]\n",
+    "\n",
+    "# Giả lập feature extractor (thực tế bạn cần xuất features từ fe1, fe2)\n",
+    "# Ở đây tạo dummy features để test ONNX\n",
+    "feature_dim = 1280\n",
+    "num_models = 2\n",
+    "features = torch.randn(batch_size, num_models, feature_dim).numpy().astype(np.float32)\n",
+    "\n",
+    "# Chạy inference với ONNX\n",
+    "outputs = session.run([\"output\"], {\"features\": features})\n",
+    "print(\"ONNX output shape:\", outputs[0].shape)\n",
+    "print(\"ONNX output:\", outputs[0])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Train2model.py

@@ -0,0 +1,77 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms, models
+from torch.utils.data import DataLoader
+from torch.multiprocessing import Process, set_start_method
+
+try:
+    set_start_method('spawn')
+except RuntimeError:
+    pass
+
+# Cấu hình
+BATCH_SIZE = 32
+EPOCHS = 10
+NUM_CLASSES = 2
+DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+DATA_ROOTS = [
+    '/home/ubuntu/vnet/TaoST/Data10kKaggle1',
+    '/home/ubuntu/vnet/TaoST/Data10kKaggle2'
+]
+MODEL_PATHS = [
+    '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle1.pth',
+    '/home/ubuntu/vnet/FL/efficientnet_b0_kaggle2.pth'
+]
+
+def get_loaders(data_root):
+    train_transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+    ])
+    test_transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+    ])
+    train_set = datasets.ImageFolder(os.path.join(data_root, 'train'), transform=train_transform)
+    test_set = datasets.ImageFolder(os.path.join(data_root, 'test'), transform=test_transform)
+    train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=4)
+    test_loader = DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=False, num_workers=4)
+    return train_loader, test_loader
+
+def train_model(data_root, model_path):
+    train_loader, test_loader = get_loaders(data_root)
+    model = models.efficientnet_b0(weights='IMAGENET1K_V1')
+    model.classifier[1] = nn.Linear(model.classifier[1].in_features, NUM_CLASSES)
+    model = model.to(DEVICE)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=1e-4)
+
+    for epoch in range(EPOCHS):
+        model.train()
+        running_loss = 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()
+            optimizer.step()
+            running_loss += loss.item() * imgs.size(0)
+        print(f"[{data_root}] Epoch {epoch+1}/{EPOCHS}, Loss: {running_loss/len(train_loader.dataset):.4f}")
+
+    torch.save(model.state_dict(), model_path)
+    print(f"Saved model to {model_path}")
+
+def main():
+    p1 = Process(target=train_model, args=(DATA_ROOTS[0], MODEL_PATHS[0]))
+    p2 = Process(target=train_model, args=(DATA_ROOTS[1], MODEL_PATHS[1]))
+    p1.start()
+    p2.start()
+    p1.join()
+    p2.join()
+
+if __name__ == "__main__":
+    main()

efficientnet_b0_kaggle1.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c85f96969b879dbc52e96bac8ae5b9e2c2b5ff9bf230e97214f0e8f79d82215a
+size 16344546

efficientnet_b0_kaggle2.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8538fba8321534a6c3dafd3f594f33d3611b025123ee7190dec064dd9b55bfcc
+size 16344546

gat_ensemble_kaggle.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1d6da93371de2c8875007d29946740da612e4d9e3932fb6b7e0879631a8cb39
+size 6570324

gat_ensemble_kaggle.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ac1f9c864b7f7f898d19b230920168d8ec06038b3688594fbe3f33317a882b1
+size 6576632