{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.15","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"tpu1vmV38","dataSources":[{"sourceId":52254,"databundleVersionId":9674523,"sourceType":"competition"},{"sourceId":6211844,"sourceType":"datasetVersion","datasetId":3567114}],"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"Hi I tried convert Keras team's code to Pytorch including all training pipeline as well.","metadata":{}},{"cell_type":"code","source":"# Cài đặt thư viện iterative-stratification\n!pip install iterative-stratification\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:33:21.998728Z","iopub.execute_input":"2024-10-03T17:33:21.998963Z","iopub.status.idle":"2024-10-03T17:37:14.534164Z","shell.execute_reply.started":"2024-10-03T17:33:21.99893Z","shell.execute_reply":"2024-10-03T17:37:14.533136Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install iterstrat==0.2.0\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:37:14.535876Z","iopub.execute_input":"2024-10-03T17:37:14.536188Z","iopub.status.idle":"2024-10-03T17:41:06.772064Z","shell.execute_reply.started":"2024-10-03T17:37:14.536129Z","shell.execute_reply":"2024-10-03T17:41:06.770992Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport torch\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\nfrom PIL import Image\nimport torch.optim as optim\nfrom torch import nn\n\nimport numpy as np\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nfrom sklearn.model_selection import KFold\nfrom sklearn.metrics import f1_score, accuracy_score","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:41:06.77338Z","iopub.execute_input":"2024-10-03T17:41:06.773645Z","iopub.status.idle":"2024-10-03T17:41:34.826201Z","shell.execute_reply.started":"2024-10-03T17:41:06.773617Z","shell.execute_reply":"2024-10-03T17:41:34.825167Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Config:\n    SEED = 42\n    IMAGE_SIZE = [256, 256]\n    BATCH_SIZE = 32\n    EPOCHS = 100\n    TARGET_COLS  = [\n        \"bowel_injury\", \"extravasation_injury\",\n        \"kidney_healthy\", \"kidney_low\", \"kidney_high\",\n        \"liver_healthy\", \"liver_low\", \"liver_high\",\n        \"spleen_healthy\", \"spleen_low\", \"spleen_high\",\n    ]\n\nconfig = Config()\nprint(f\"Số lượng nhãn mục tiêu: {len(Config.TARGET_COLS)}\")\ntorch.manual_seed(Config.SEED)\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:41:34.828197Z","iopub.execute_input":"2024-10-03T17:41:34.828619Z","iopub.status.idle":"2024-10-03T17:41:34.843936Z","shell.execute_reply.started":"2024-10-03T17:41:34.82859Z","shell.execute_reply":"2024-10-03T17:41:34.843201Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Loading Data","metadata":{}},{"cell_type":"code","source":"# Đường dẫn cơ bản đến dữ liệu\nBASE_PATH = f\"/kaggle/input/rsna-atd-512x512-png-v2-dataset\"\n\n# Tải dữ liệu train\ndataframe = pd.read_csv(f\"{BASE_PATH}/train.csv\")\ndataframe[\"image_path\"] = (\n    f\"{BASE_PATH}/train_images/\"\n    + dataframe.patient_id.astype(str)\n    + \"/\"\n    + dataframe.series_id.astype(str)\n    + \"/\"\n    + dataframe.instance_number.astype(str) + \".png\"\n)\ndataframe = dataframe.drop_duplicates()\nprint(dataframe.head(10))\n","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2024-10-03T17:41:34.844865Z","iopub.execute_input":"2024-10-03T17:41:34.84511Z","iopub.status.idle":"2024-10-03T17:41:34.941504Z","shell.execute_reply.started":"2024-10-03T17:41:34.845074Z","shell.execute_reply":"2024-10-03T17:41:34.940548Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class CustomDataset(Dataset):\n    def __init__(self, paths, labels, transform=None):\n        self.paths = paths\n        self.labels = labels\n        self.transform = transform\n\n    def __len__(self):\n        return len(self.paths)\n\n    def __getitem__(self, idx):\n        image = Image.open(self.paths[idx]).convert('RGB')\n        label = torch.tensor(self.labels[idx], dtype=torch.float32)\n\n        if self.transform:\n            image = self.transform(image)\n\n        return image, label\n\n# Định nghĩa các chuyển đổi ảnh, bao gồm augmentation\ntransform = transforms.Compose([\n    transforms.Resize((256, 256)),\n    transforms.RandomResizedCrop(256),   # Cắt ngẫu nhiên và thay đổi kích thước\n    transforms.RandomHorizontalFlip(),    # Lật ngang ngẫu nhiên\n    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),  # Biến đổi màu sắc\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n])\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:41:34.94277Z","iopub.execute_input":"2024-10-03T17:41:34.943026Z","iopub.status.idle":"2024-10-03T17:41:34.949907Z","shell.execute_reply.started":"2024-10-03T17:41:34.943001Z","shell.execute_reply":"2024-10-03T17:41:34.949185Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class SimpleCNN(nn.Module):\n    def __init__(self, num_classes=11):\n        super(SimpleCNN, self).__init__()\n        \n        self.conv_layers = nn.Sequential(\n            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(kernel_size=2, stride=2),\n            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(kernel_size=2, stride=2)\n        )\n        \n        self.fc_layers = nn.Sequential(\n            nn.Linear(64 * 64 * 64, 128),\n            nn.ReLU(),\n            nn.Linear(128, num_classes)\n        )\n        \n    def forward(self, x):\n        x = self.conv_layers(x)\n        x = x.view(x.size(0), -1)\n        x = self.fc_layers(x)\n        return x\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:41:34.950961Z","iopub.execute_input":"2024-10-03T17:41:34.951263Z","iopub.status.idle":"2024-10-03T17:41:34.963887Z","shell.execute_reply.started":"2024-10-03T17:41:34.951217Z","shell.execute_reply":"2024-10-03T17:41:34.963178Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Số lượng folds\nK = 4  # Bạn có thể chọn 5 hoặc 10 tùy ý\n\n# Khởi tạo K-Fold splitter\nkf = KFold(n_splits=K, shuffle=True, random_state=config.SEED)\n\n# Chuẩn bị dữ liệu\nX = dataframe.image_path.values\ny = dataframe[config.TARGET_COLS].values\n\n# Khởi tạo danh sách để lưu trữ các chỉ số và metric của từng fold\nfold_train_losses = []\nfold_val_losses = []\nfold_val_accuracies = []\nfold_val_f1_scores = []\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:41:34.964876Z","iopub.execute_input":"2024-10-03T17:41:34.965128Z","iopub.status.idle":"2024-10-03T17:41:34.975552Z","shell.execute_reply.started":"2024-10-03T17:41:34.965102Z","shell.execute_reply":"2024-10-03T17:41:34.97478Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# torch dataloader with augmentation","metadata":{}},{"cell_type":"code","source":"# Kiểm tra nếu có GPU thì sử dụng, nếu không sẽ sử dụng CPU\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"Using device: {device}\")\n\nfor fold, (train_idx, val_idx) in enumerate(kf.split(X)):\n    print(f\"\\n=== Fold {fold + 1}/{K} ===\")\n    \n    # Chia dữ liệu thành train và validation\n    train_paths, val_paths = X[train_idx], X[val_idx]\n    train_labels, val_labels = y[train_idx], y[val_idx]\n    \n    # Tạo dataset và dataloader cho từng fold\n    dataset_train = CustomDataset(train_paths, train_labels, transform=transform)\n    dataset_val = CustomDataset(val_paths, val_labels, transform=transform)\n    \n    train_dataloader = DataLoader(dataset_train, batch_size=config.BATCH_SIZE, shuffle=True, num_workers=4, pin_memory=True)\n    val_dataloader = DataLoader(dataset_val, batch_size=config.BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)\n    \n    # Khởi tạo mô hình, loss function, optimizer và scheduler cho từng fold\n    model = SimpleCNN(num_classes=len(config.TARGET_COLS)).to(device)\n    criterion = nn.BCEWithLogitsLoss()\n    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=config.EPOCHS)\n    \n    # Khởi tạo danh sách để lưu trữ các metric trong từng fold\n    train_losses = []\n    val_losses = []\n    val_accuracies = []\n    val_f1_scores_fold = []\n    \n    # Vòng lặp huấn luyện trong từng fold\n    for epoch in range(config.EPOCHS):\n        model.train()\n        running_loss = 0.0\n        for images, labels in train_dataloader:\n            optimizer.zero_grad()\n            \n            # Đẩy dữ liệu lên thiết bị\n            images = images.to(device, non_blocking=True)\n            labels = labels.to(device, non_blocking=True)\n            \n            # Forward pass\n            outputs = model(images)\n            loss = criterion(outputs, labels)\n            \n            # Backward pass và tối ưu hóa\n            loss.backward()\n            optimizer.step()\n            \n            running_loss += loss.item() * images.size(0)\n        \n        epoch_train_loss = running_loss / len(train_dataloader.dataset)\n        train_losses.append(epoch_train_loss)\n        \n        # Cập nhật learning rate\n        scheduler.step()\n        \n        # Vòng lặp validation\n        model.eval()\n        val_loss = 0.0\n        correct = 0\n        total = 0\n        all_preds = []\n        all_targets = []\n        \n        with torch.no_grad():\n            for images, labels in val_dataloader:\n                images = images.to(device, non_blocking=True)\n                labels = labels.to(device, non_blocking=True)\n                \n                outputs = model(images)\n                loss = criterion(outputs, labels)\n                val_loss += loss.item() * images.size(0)\n                \n                preds = torch.sigmoid(outputs) > 0.5\n                correct += (preds.int() == labels.int()).sum().item()\n                total += labels.numel()\n                \n                all_preds.append(preds.cpu().numpy())\n                all_targets.append(labels.cpu().numpy())\n        \n        epoch_val_loss = val_loss / len(val_dataloader.dataset)\n        val_losses.append(epoch_val_loss)\n        \n        # Tính accuracy\n        epoch_val_accuracy = 100.0 * correct / total\n        val_accuracies.append(epoch_val_accuracy)\n        \n        # Tính F1 Score\n        all_preds_np = np.vstack(all_preds)\n        all_targets_np = np.vstack(all_targets)\n        epoch_f1 = f1_score(all_targets_np, all_preds_np, average='macro')\n        val_f1_scores_fold.append(epoch_f1)\n        \n        print(f\"Epoch [{epoch+1}/{config.EPOCHS}] - \"\n              f\"Train Loss: {epoch_train_loss:.4f} - \"\n              f\"Val Loss: {epoch_val_loss:.4f} - \"\n              f\"Val Acc: {epoch_val_accuracy:.2f}% - \"\n              f\"Val F1: {epoch_f1:.4f}\")\n    \n    # Sau mỗi fold, lưu trữ các metric\n    fold_train_losses.append(train_losses)\n    fold_val_losses.append(val_losses)\n    fold_val_accuracies.append(val_accuracies)\n    fold_val_f1_scores.append(val_f1_scores_fold)\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T17:41:34.976846Z","iopub.execute_input":"2024-10-03T17:41:34.977213Z","iopub.status.idle":"2024-10-03T19:35:57.158894Z","shell.execute_reply.started":"2024-10-03T17:41:34.977184Z","shell.execute_reply":"2024-10-03T19:35:57.156898Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Converting Dataframe to dataloader","metadata":{}},{"cell_type":"code","source":"# Chuyển đổi danh sách thành numpy array để dễ dàng tính toán\nfold_train_losses = np.array(fold_train_losses)\nfold_val_losses = np.array(fold_val_losses)\nfold_val_accuracies = np.array(fold_val_accuracies)\nfold_val_f1_scores = np.array(fold_val_f1_scores)\n\n# Tính trung bình và độ lệch chuẩn cho từng metric\nmean_train_loss = fold_train_losses.mean(axis=0)\nstd_train_loss = fold_train_losses.std(axis=0)\n\nmean_val_loss = fold_val_losses.mean(axis=0)\nstd_val_loss = fold_val_losses.std(axis=0)\n\nmean_val_accuracy = fold_val_accuracies.mean(axis=0)\nstd_val_accuracy = fold_val_accuracies.std(axis=0)\n\nmean_val_f1 = fold_val_f1_scores.mean(axis=0)\nstd_val_f1 = fold_val_f1_scores.std(axis=0)\n\nprint(\"\\n=== Cross-Validation Results ===\")\nprint(f\"Average Final Validation Loss: {mean_val_loss[-1]:.4f} ± {std_val_loss[-1]:.4f}\")\nprint(f\"Average Final Validation Accuracy: {mean_val_accuracy[-1]:.2f}% ± {std_val_accuracy[-1]:.2f}%\")\nprint(f\"Average Final Validation F1 Score: {mean_val_f1[-1]:.4f} ± {std_val_f1[-1]:.4f}\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.159784Z","iopub.status.idle":"2024-10-03T19:35:57.160147Z","shell.execute_reply.started":"2024-10-03T19:35:57.159976Z","shell.execute_reply":"2024-10-03T19:35:57.159995Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Vẽ đồ thị mất mát (loss)\nplt.figure(figsize=(18, 5))\n\n# Đồ thị mất mát train\nplt.subplot(1, 3, 1)\nfor fold in range(K):\n    plt.plot(fold_train_losses[fold], label=f'Fold {fold+1}')\nplt.title('Training Loss per Fold')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.legend()\n\n# Đồ thị mất mát validation\nplt.subplot(1, 3, 2)\nfor fold in range(K):\n    plt.plot(fold_val_losses[fold], label=f'Fold {fold+1}')\nplt.title('Validation Loss per Fold')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.legend()\n\n# Đồ thị Accuracy và F1 Score\nplt.subplot(1, 3, 3)\nfor fold in range(K):\n    plt.plot(fold_val_accuracies[fold], label=f'Fold {fold+1} Acc')\n    plt.plot(fold_val_f1_scores[fold], label=f'Fold {fold+1} F1')\nplt.title('Validation Accuracy & F1 Score per Fold')\nplt.xlabel('Epoch')\nplt.ylabel('Metric')\nplt.legend()\n\nplt.tight_layout()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.160842Z","iopub.status.idle":"2024-10-03T19:35:57.161155Z","shell.execute_reply.started":"2024-10-03T19:35:57.160998Z","shell.execute_reply":"2024-10-03T19:35:57.161015Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## display some images","metadata":{}},{"cell_type":"code","source":"# Giả sử bạn muốn lưu trữ mô hình có F1 Score tốt nhất trong mỗi fold\nfor fold in range(K):\n    best_epoch = np.argmax(fold_val_f1_scores[fold])\n    best_model_path = f\"best_model_fold_{fold+1}_epoch_{best_epoch+1}.pth\"\n    torch.save(model.state_dict(), best_model_path)\n    print(f\"Đã lưu mô hình tốt nhất cho Fold {fold+1} tại epoch {best_epoch+1}\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.161903Z","iopub.status.idle":"2024-10-03T19:35:57.162185Z","shell.execute_reply.started":"2024-10-03T19:35:57.162041Z","shell.execute_reply":"2024-10-03T19:35:57.162056Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Simple CNN","metadata":{}},{"cell_type":"code","source":"# Ví dụ: Huấn luyện mô hình cuối cùng trên toàn bộ dữ liệu huấn luyện\nfull_train_dataset = CustomDataset(dataframe.image_path.tolist(), dataframe[config.TARGET_COLS].values, transform=transform)\nfull_train_dataloader = DataLoader(full_train_dataset, batch_size=config.BATCH_SIZE, shuffle=True, num_workers=4, pin_memory=True)\n\n# Khởi tạo mô hình cuối cùng\nfinal_model = SimpleCNN(num_classes=len(config.TARGET_COLS)).to('cuda')\n\n# Định nghĩa loss function và optimizer\ncriterion = nn.BCEWithLogitsLoss()\noptimizer = torch.optim.Adam(final_model.parameters(), lr=1e-4)\nscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=config.EPOCHS)\n\n# Vòng lặp huấn luyện cho mô hình cuối cùng\nfor epoch in range(config.EPOCHS):\n    final_model.train()\n    running_loss = 0.0\n    for images, labels in full_train_dataloader:\n        optimizer.zero_grad()\n        \n        # Đẩy dữ liệu lên GPU\n        images = images.to('cuda', non_blocking=True)\n        labels = labels.to('cuda', non_blocking=True)\n        \n        # Forward pass\n        outputs = final_model(images)\n        loss = criterion(outputs, labels)\n        \n        # Backward pass và tối ưu hóa\n        loss.backward()\n        optimizer.step()\n        \n        running_loss += loss.item() * images.size(0)\n    \n    epoch_train_loss = running_loss / len(full_train_dataloader.dataset)\n    scheduler.step()\n    \n    print(f\"Epoch [{epoch+1}/{config.EPOCHS}] - Train Loss: {epoch_train_loss:.4f}\")\n\n# Lưu mô hình cuối cùng\ntorch.save(final_model.state_dict(), \"final_model.pth\")\nprint(\"Đã lưu mô hình cuối cùng.\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.162905Z","iopub.status.idle":"2024-10-03T19:35:57.163179Z","shell.execute_reply.started":"2024-10-03T19:35:57.163039Z","shell.execute_reply":"2024-10-03T19:35:57.163053Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## training the model","metadata":{}},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\n\n\n# Instantiate the model\nmodel = SimpleCNN(num_classes=11).to('cuda')\n\n# Define loss function and optimizer\ncriterion = nn.BCEWithLogitsLoss()  # Use BCEWithLogitsLoss for binary classification\noptimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\nscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=5)\n\ntotal_epochs = 200  # Replace with the total number of epochs\n#số ep chạy\n\ntrain_losses = []  # To store training losses\nval_losses = []    # To store validation losses\nval_accuracies = []  # To store validation accuracies\n\nfor epoch in range(total_epochs):\n    model.train()  # Set the model to training mode\n    for images, labels in train_dataloader:\n        optimizer.zero_grad()\n        \n        # Move data to GPU\n        images = images.to('cuda')\n        labels = labels.to('cuda')\n        \n        outputs = model(images)\n        \n        loss = criterion(outputs, labels)\n        \n        loss.backward()\n        optimizer.step()\n    \n    # Update learning rate using the scheduler\n    scheduler.step()\n    \n    # Validation loop\n    model.eval()  # Set the model to evaluation mode\n    val_loss = 0.0\n    correct = 0\n    total = 0\n    with torch.no_grad():\n        for images, labels in val_dataloader:\n            images = images.to('cuda')\n            labels = labels.to('cuda')\n            \n            outputs = model(images)\n            val_loss += criterion(outputs, labels).item()\n            \n            predicted = (outputs > 0.5).int()  # Convert logits to binary predictions\n            total += labels.size(0) * labels.size(1)  # Total number of predictions\n            correct += (predicted == labels).sum().item()\n    \n    val_loss /= len(val_dataloader)\n    val_accuracy = 100.0 * correct / total\n    \n     # Append loss and accuracy values to lists\n    train_losses.append(loss.item())\n    val_losses.append(val_loss)\n    val_accuracies.append(val_accuracy)\n    print(f\"Epoch [{epoch+1}/{total_epochs}] - Loss: {loss:.4f} - Val Loss: {val_loss:.4f} - Val Acc: {val_accuracy:.2f}%\")","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.163837Z","iopub.status.idle":"2024-10-03T19:35:57.164109Z","shell.execute_reply.started":"2024-10-03T19:35:57.163974Z","shell.execute_reply":"2024-10-03T19:35:57.163989Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Plot training and validation progress\nplt.figure(figsize=(12, 4))\nplt.subplot(1, 2, 1)\nplt.plot(train_losses, label='Train')\nplt.plot(val_losses, label='Validation')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.legend()\nplt.title('Training and Validation Loss')\n\nplt.subplot(1, 2, 2)\nplt.plot(val_accuracies, label='Validation')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy (%)')\nplt.legend()\nplt.title('Validation Accuracy')\n\nplt.tight_layout()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.164891Z","iopub.status.idle":"2024-10-03T19:35:57.165163Z","shell.execute_reply.started":"2024-10-03T19:35:57.165027Z","shell.execute_reply":"2024-10-03T19:35:57.165041Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\n\n# Set the model to evaluation mode\nmodel.eval()\n\n# Select a random image from the validation dataset\nrandom_index = np.random.randint(len(dataset_val))\nimage, label = dataset_val[random_index]\n\n# Move the image to the GPU if available\nimage = image.to('cuda')\n\n# Pass the image through the model\nwith torch.no_grad():\n    output = model(image.unsqueeze(0))  # Unsqueeze to add batch dimension\n\n# Convert the output logits to probabilities using sigmoid function\npredicted_probs = torch.sigmoid(output)[0]\n\n# Convert predicted probabilities to binary predictions\npredicted_labels = (predicted_probs > 0.5).int()\n\n\n# Display the image, actual labels, and predicted labels\nplt.imshow(image.permute(1, 2, 0).cpu())  # Move image to CPU and change channel order\n#plt.title(f\"Actual Labels: {label}\\nPredicted Labels: {predicted_labels}\")\nplt.title(f\"Actual Labels: {label}\\nPredicted Labels: {predicted_labels}\")\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.165755Z","iopub.status.idle":"2024-10-03T19:35:57.166035Z","shell.execute_reply.started":"2024-10-03T19:35:57.1659Z","shell.execute_reply":"2024-10-03T19:35:57.165914Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_sub = pd.read_csv(\"/kaggle/input/rsna-atd-512x512-png-v2-dataset/sample_submission.csv\")\ndf_sub","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.166677Z","iopub.status.idle":"2024-10-03T19:35:57.166949Z","shell.execute_reply.started":"2024-10-03T19:35:57.166813Z","shell.execute_reply":"2024-10-03T19:35:57.166828Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission_paths= [\"/kaggle/input/rsna-atd-512x512-png-v2-dataset/test_images/48843/62825/30.png\",\n                \"/kaggle/input/rsna-atd-512x512-png-v2-dataset/test_images/50046/24574/30.png\",\n                \"/kaggle/input/rsna-atd-512x512-png-v2-dataset/test_images/63706/39279/30.png\"\n               ]\nid_list = [48843, 50046, 63706]","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.167572Z","iopub.status.idle":"2024-10-03T19:35:57.16785Z","shell.execute_reply.started":"2024-10-03T19:35:57.167715Z","shell.execute_reply":"2024-10-03T19:35:57.16773Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"#random_seed = 42  # You can use any number\n#np.random.seed(random_seed)\n\nimport torch.nn.functional as F\ndef predict_classes(image_paths):\n    predictions = []\n    for image_path in image_paths:\n        image = Image.open(image_path).convert('RGB')\n        input_image = transform(image).unsqueeze(0).to(\"cuda\")\n        with torch.no_grad():\n            output = model(input_image)\n        predicted_probs = F.sigmoid(output)[0]\n        predicted_class_index = (predicted_probs > 0.5).int()\n        predictions.append({'Image Path': image_path, 'Predicted Class Index': predicted_class_index.cpu().numpy()})\n    return pd.DataFrame(predictions)\n\ndf = predict_classes(submission_paths)\ndf[\"patient_id\"] = id_list\ndf[config.TARGET_COLS] = df['Predicted Class Index'].apply(pd.Series)\ndf.drop([\"Image Path\", \"Predicted Class Index\"], axis=1, inplace=True)","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.168489Z","iopub.status.idle":"2024-10-03T19:35:57.168769Z","shell.execute_reply.started":"2024-10-03T19:35:57.168631Z","shell.execute_reply":"2024-10-03T19:35:57.168647Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.169558Z","iopub.status.idle":"2024-10-03T19:35:57.169877Z","shell.execute_reply.started":"2024-10-03T19:35:57.169719Z","shell.execute_reply":"2024-10-03T19:35:57.169736Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.to_csv(\"submission.csv\")","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.170534Z","iopub.status.idle":"2024-10-03T19:35:57.170858Z","shell.execute_reply.started":"2024-10-03T19:35:57.170692Z","shell.execute_reply":"2024-10-03T19:35:57.170709Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"learning_rates = [0.001, 0.005, 0.01, 0.05, 0.1]\nprint(\"Learning Rates:\", learning_rates)\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.171531Z","iopub.status.idle":"2024-10-03T19:35:57.17181Z","shell.execute_reply.started":"2024-10-03T19:35:57.171676Z","shell.execute_reply":"2024-10-03T19:35:57.17169Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch\nimport numpy as np\nimport torch.nn as nn\nimport torch.optim as optim\n\n# Giả sử dữ liệu của bạn đang ở dạng numpy arrays\nX_train_np = np.random.rand(100, 10)  # Ví dụ dữ liệu đầu vào\ny_train_np = np.random.randint(0, 2, (100,))  # Ví dụ nhãn\nX_val_np = np.random.rand(20, 10)  # Ví dụ dữ liệu validation\ny_val_np = np.random.randint(0, 2, (20,))  # Ví dụ nhãn validation\n\n# Chuyển đổi từ numpy arrays sang torch tensors\nX_train = torch.tensor(X_train_np, dtype=torch.float32)\ny_train = torch.tensor(y_train_np, dtype=torch.long)\nX_val = torch.tensor(X_val_np, dtype=torch.float32)\ny_val = torch.tensor(y_val_np, dtype=torch.long)\n\n# Định nghĩa lớp mô hình\nclass MyModel(nn.Module):\n    def __init__(self):\n        super(MyModel, self).__init__()\n        self.fc1 = nn.Linear(10, 50)  # Ví dụ, đầu vào là 10, đầu ra là 50\n        self.fc2 = nn.Linear(50, 2)   # Ví dụ, đầu ra cuối cùng có 2 lớp (classes)\n    \n    def forward(self, x):\n        x = torch.relu(self.fc1(x))\n        x = self.fc2(x)\n        return x\n\n# Khởi tạo mô hình\nmodel = MyModel()\n\n# Định nghĩa các hyperparameters\nlearning_rates = [0.001, 0.005, 0.01, 0.05, 0.1]\nnum_epochs = 10  # Thay đổi số lượng epochs theo nhu cầu của bạn\n\nfor lr in learning_rates:\n    print(f\"Training with learning rate: {lr}\")\n    \n    # Tạo optimizer với tỷ lệ học hiện tại\n    optimizer = optim.Adam(model.parameters(), lr=lr)\n    \n    # Định nghĩa hàm mất mát\n    criterion = nn.CrossEntropyLoss()\n    \n    # Huấn luyện mô hình\n    for epoch in range(num_epochs):\n        model.train()\n        optimizer.zero_grad()\n        \n        # Tiền xử lý dữ liệu\n        outputs = model(X_train)\n        loss = criterion(outputs, y_train)\n        \n        # Lan truyền ngược và cập nhật tham số\n        loss.backward()\n        optimizer.step()\n    \n    # Đánh giá mô hình trên dữ liệu validation\n    model.eval()\n    with torch.no_grad():\n        val_outputs = model(X_val)\n        val_loss = criterion(val_outputs, y_val)\n    \n    print(f\"Validation Loss: {val_loss.item()}\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-03T19:35:57.172452Z","iopub.status.idle":"2024-10-03T19:35:57.172727Z","shell.execute_reply.started":"2024-10-03T19:35:57.17259Z","shell.execute_reply":"2024-10-03T19:35:57.172605Z"},"trusted":true},"execution_count":null,"outputs":[]}]}