{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":14774,"databundleVersionId":875431,"sourceType":"competition"},{"sourceId":46865,"sourceType":"datasetVersion","datasetId":34835},{"sourceId":2037383,"sourceType":"datasetVersion","datasetId":1220153},{"sourceId":2812287,"sourceType":"datasetVersion","datasetId":1719146},{"sourceId":3242401,"sourceType":"datasetVersion","datasetId":1965297},{"sourceId":5203002,"sourceType":"datasetVersion","datasetId":3025918},{"sourceId":232835714,"sourceType":"kernelVersion"}],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import os\nimport torch\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom torchvision import datasets, transforms\nfrom torch.utils.data import DataLoader, random_split\nfrom PIL import Image\n\n# Set the seed for all libraries\nseed = 42\ntorch.manual_seed(seed)\ntorch.cuda.manual_seed_all(seed)  # For multi-GPU setup\nnp.random.seed(seed)\n\n# Set deterministic behavior for cuDNN\ntorch.backends.cudnn.deterministic = True\ntorch.backends.cudnn.benchmark = False","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torchvision.models as models\nfrom sklearn.metrics import f1_score, cohen_kappa_score,confusion_matrix","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class ResNetModel(nn.Module):\n    def __init__(self, num_classes=5, pretrained=True):  # Add `num_classes` parameter\n        super(ResNetModel, self).__init__()\n        self.resnet = models.resnet18(pretrained=pretrained)  # Load ResNet18\n        \n        # Remove the original FC layer\n        num_ftrs = self.resnet.fc.in_features\n        self.resnet.fc = nn.Identity()  # Remove the last layer\n        \n        # Add custom classifier layers\n        self.classifier = nn.Sequential(\n            nn.Linear(num_ftrs, 256),  # First Dense layer\n            nn.ReLU(),\n            nn.Dropout(0.5),  # Dropout to prevent overfitting\n            nn.Linear(256, 128),  # Second Dense layer\n            nn.ReLU(),\n            nn.Dropout(0.5),\n            nn.Linear(128, num_classes)  # Output layer for multi-class classification\n        )\n\n    def forward(self, x):\n        x = self.resnet(x)  # Extract features from ResNet\n        x = self.classifier(x)  # Pass through classifier\n        return x","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n\nmodel = ResNetModel(pretrained=False).to(device)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Messidor1_Data","metadata":{}},{"cell_type":"code","source":"import torch.optim as optim\nimport torchvision.transforms as transforms\nimport torchvision.models as models\nfrom torch.utils.data import DataLoader, Dataset\nfrom PIL import Image\nimport numpy as np\nfrom sklearn.metrics import cohen_kappa_score, accuracy_score,classification_report","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nfrom torch.utils.data import Dataset\nfrom PIL import Image\n\nclass MessidorDataset(Dataset):\n    def __init__(self, root_dir, transform=None):\n        self.root_dir = root_dir\n        self.transform = transform\n        self.image_paths = []\n        self.labels = []\n\n        # Iterate over all folders (0, 1, 2, 3) and collect valid image paths\n        for label in [0, 1, 2, 3]:  # Include all classes\n            folder_path = os.path.join(root_dir, str(label))\n            for filename in os.listdir(folder_path):\n                if filename.endswith(\".tif\"):\n                    self.image_paths.append(os.path.join(folder_path, filename))\n                    self.labels.append(label)  # Use the original class label\n\n    def __len__(self):\n        return len(self.image_paths)\n\n    def __getitem__(self, idx):\n        img_path = self.image_paths[idx]\n        label = self.labels[idx]\n\n        # Open the image and apply transformations\n        image = Image.open(img_path).convert(\"RGB\")\n        if self.transform:\n            image = self.transform(image)\n\n        return image, label","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================\n# Data Transformations & Dataloaders\n# ============================\ntransform = transforms.Compose([\n    transforms.Resize((224, 224)),  # Resizing for ResNet\n    transforms.ToTensor(),\n    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n])\n\ntest_dir = \"/kaggle/input/messidor1-data/P_Data/Test\"\n\ntest_dataset = MessidorDataset(test_dir, transform=transform)\n\ntest_loader = DataLoader(test_dataset, batch_size=16, shuffle=False)\n\nprint(f\"Testing samples: {len(test_dataset)}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import accuracy_score, cohen_kappa_score, classification_report, confusion_matrix\n\n# ============================\n# Evaluation Function (QWK & Accuracy)\n# ============================\ndef evaluate(model, test_loader):\n    model.eval()\n    y_true = []\n    y_pred = []\n\n    with torch.no_grad():\n        for images, labels in test_loader:\n            images, labels = images.to(device), labels.to(device)\n\n            outputs = model(images)\n            _, preds = torch.max(outputs, 1)  # Get predicted class indices\n\n            y_true.extend(labels.cpu().numpy())\n            y_pred.extend(preds.cpu().numpy())\n\n    # Compute Accuracy & Quadratic Weighted Kappa (QWK)\n    accuracy = accuracy_score(y_true, y_pred)\n    qwk = cohen_kappa_score(y_true, y_pred, weights='quadratic')\n\n    print(f\"✅ Test Accuracy: {accuracy:.4f}\")\n    print(f\"✅ Quadratic Weighted Kappa (QWK): {qwk:.4f}\")\n    \n    print(\"Classification Report:\")\n    print(classification_report(y_true, y_pred, target_names=[f\"Class {i}\" for i in range(5)]))  # Adjust for 5 classes\n    \n    print(\"Confusion Matrix:\")\n    print(confusion_matrix(y_true, y_pred))\n    \n    return y_true, y_pred","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model.load_state_dict(torch.load(\"/kaggle/input/multi-class-eyepacs-ddr-resnet-model/EyePacs_DDR_best_resnet_model.pth\"))\nmodel.eval()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================\n# Run Evaluation\n# ============================\ny_true ,y_pred = evaluate(model, test_loader)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import confusion_matrix\n\n# Compute confusion matrix\ncm = confusion_matrix(y_true, y_pred)\n\n# Plot confusion matrix\nplt.figure(figsize=(8, 7))  # Adjust figure size for better readability\nsns.heatmap(\n    cm, \n    annot=True, \n    fmt=\"d\", \n    cmap=\"Blues\", \n    xticklabels=[f\"Class {i}\" for i in range(4)],  # Labels for predicted classes\n    yticklabels=[f\"Class {i}\" for i in range(4)]   # Labels for true classes\n)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"True Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\n\n# Convert predictions to numpy for histogram\ny_pred = np.array(y_pred)\n\n# Define the number of classes\nnum_classes = 4  # Classes: 0, 1, 2, 3\n\nplt.figure(figsize=(8, 6))  # Adjust figure size for better readability\nplt.hist(\n    y_pred, \n    bins=np.arange(-0.5, num_classes + 0.5, 1),  # Bin edges for class indices\n    edgecolor='black', \n    alpha=0.7, \n    color='blue'\n)\nplt.xticks(range(num_classes), labels=[f\"Class {i}\" for i in range(num_classes)])  # Labels for classes\nplt.xlabel(\"Predicted Class\")\nplt.ylabel(\"Count\")\nplt.title(\"Distribution of Predictions\")\nplt.grid(axis=\"y\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import precision_recall_curve, average_precision_score\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class precision-recall curve\ny_true_bin = label_binarize(y_true, classes=[0, 1, 2, 3])  # One-hot encode true labels\ny_pred_bin = label_binarize(y_pred, classes=[0, 1, 2, 3])  # One-hot encode predicted labels\n\n# Compute precision-recall curve for each class\nprecision = dict()\nrecall = dict()\naverage_precision = dict()\n\nn_classes = y_true_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    precision[i], recall[i], _ = precision_recall_curve(y_true_bin[:, i], y_pred_bin[:, i])\n    average_precision[i] = average_precision_score(y_true_bin[:, i], y_pred_bin[:, i])\n\n# Compute micro-average precision-recall curve\nprecision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(\n    y_true_bin.ravel(), y_pred_bin.ravel()\n)\naverage_precision[\"micro\"] = average_precision_score(y_true_bin, y_pred_bin, average=\"micro\")\n\n# Plot precision-recall curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        recall[i],\n        precision[i],\n        label=f\"Class {i} (AP = {average_precision[i]:.2f})\",\n    )\n\n# Plot micro-average precision-recall curve\nplt.plot(\n    recall[\"micro\"],\n    precision[\"micro\"],\n    label=f\"Micro-Average (AP = {average_precision['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.xlabel(\"Recall\")\nplt.ylabel(\"Precision\")\nplt.title(\"Precision-Recall Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower left\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import roc_curve, auc\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class ROC curve\ny_true_bin = label_binarize(y_true, classes=[0, 1, 2, 3])  # One-hot encode true labels\ny_pred_bin = label_binarize(y_pred, classes=[0, 1, 2, 3])  # One-hot encode predicted labels\n\n# Compute ROC curve and AUC for each class\nfpr = dict()\ntpr = dict()\nroc_auc = dict()\n\nn_classes = y_true_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    fpr[i], tpr[i], _ = roc_curve(y_true_bin[:, i], y_pred_bin[:, i])\n    roc_auc[i] = auc(fpr[i], tpr[i])\n\n# Compute micro-average ROC curve and AUC\nfpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(\n    y_true_bin.ravel(), y_pred_bin.ravel()\n)\nroc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n# Plot ROC curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        fpr[i],\n        tpr[i],\n        label=f\"Class {i} (AUC = {roc_auc[i]:.2f})\",\n    )\n\n# Plot micro-average ROC curve\nplt.plot(\n    fpr[\"micro\"],\n    tpr[\"micro\"],\n    label=f\"Micro-Average (AUC = {roc_auc['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.plot([0, 1], [0, 1], color=\"gray\", linestyle=\"--\")  # Diagonal line\nplt.xlabel(\"False Positive Rate\")\nplt.ylabel(\"True Positive Rate\")\nplt.title(\"Receiver Operating Characteristic (ROC) Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower right\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# IDRiD: Diabetic Retinopathy – Grading","metadata":{}},{"cell_type":"code","source":"# Define dataset paths\nimage_dir = \"/kaggle/input/idrid-dataset/Imagenes/Imagenes\"\ncsv_file = \"/kaggle/input/idrid-dataset/idrid_labels.csv\"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define image transformations\ntransform = transforms.Compose([\n    transforms.Resize((224, 224)),  # Resize images to match model input\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define dataset class\nclass IDRiDDataset(Dataset):\n    def __init__(self, image_dir, csv_file, transform=None):\n        self.image_dir = image_dir\n        self.transform = transform\n        self.df = pd.read_csv(csv_file)\n\n        # Ensure column names are correctly read\n        self.df.columns = self.df.columns.str.strip()\n\n    def __len__(self):\n        return len(self.df)\n\n    def __getitem__(self, idx):\n        # Extract image ID and label\n        img_id = self.df.iloc[idx][\"id_code\"]\n        label = self.df.iloc[idx][\"diagnosis\"]  # Use the original class label (0 to 4)\n\n        # Load image\n        img_path = os.path.join(self.image_dir, img_id + \".jpg\")\n        try:\n            image = Image.open(img_path).convert(\"RGB\")\n        except Exception as e:\n            print(f\"Error loading image {img_path}: {e}\")\n            return None, None\n\n        # Apply transformations\n        if self.transform:\n            image = self.transform(image)\n\n        return image, label","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Create dataset and dataloader\nbatch_size = 64\ntest_dataset = IDRiDDataset(image_dir=image_dir, csv_file=csv_file, transform=transform)\ntest_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Load trained model\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel.to(device)\nmodel.eval()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import accuracy_score, cohen_kappa_score, classification_report, confusion_matrix\n\n# Evaluation function\ndef evaluate_model(model, dataloader):\n    all_preds = []\n    all_labels = []\n\n    with torch.no_grad():\n        for images, labels in dataloader:\n            images, labels = images.to(device), labels.to(device)\n            \n            # Forward pass\n            outputs = model(images)\n            _, preds = torch.max(outputs, 1)  # Get predicted class indices\n\n            # Store predictions and true labels\n            all_preds.extend(preds.cpu().numpy())\n            all_labels.extend(labels.cpu().numpy())\n\n    # Compute evaluation metrics\n    accuracy = accuracy_score(all_labels, all_preds)\n    qwk = cohen_kappa_score(all_labels, all_preds, weights='quadratic')\n\n    print(f\"Accuracy: {accuracy:.4f}\")\n    print(f\"Quadratic Weighted Kappa (QWK): {qwk:.4f}\")\n    \n    print(\"Classification Report:\")\n    print(classification_report(all_labels, all_preds, target_names=[f\"Class {i}\" for i in range(5)]))  # Adjust for 5 classes\n    \n    print(\"Confusion Matrix:\")\n    print(confusion_matrix(all_labels, all_preds))\n    \n    return all_labels, all_preds\n\n# Run evaluation\nall_labels, all_preds = evaluate_model(model, test_loader)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import confusion_matrix\n\n# Compute confusion matrix\ncm = confusion_matrix(all_labels, all_preds)\n\n# Plot confusion matrix\nplt.figure(figsize=(8, 7))  # Adjust figure size for better readability\nsns.heatmap(\n    cm, \n    annot=True, \n    fmt=\"d\", \n    cmap=\"Blues\", \n    xticklabels=[f\"Class {i}\" for i in range(5)],  # Labels for predicted classes\n    yticklabels=[f\"Class {i}\" for i in range(5)]   # Labels for true classes\n)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"True Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\n\n# Convert predictions to numpy for histogram\nall_preds = np.array(all_preds)\n\n# Define the number of classes\nnum_classes = 5  # Classes: 0, 1, 2, 3, 4\n\nplt.figure(figsize=(8, 6))  # Adjust figure size for better readability\nplt.hist(\n    all_preds, \n    bins=np.arange(-0.5, num_classes + 0.5, 1),  # Bin edges for class indices\n    edgecolor='black', \n    alpha=0.7, \n    color='blue'\n)\nplt.xticks(range(num_classes), labels=[f\"Class {i}\" for i in range(num_classes)])  # Labels for classes\nplt.xlabel(\"Predicted Class\")\nplt.ylabel(\"Count\")\nplt.title(\"Distribution of Predictions\")\nplt.grid(axis=\"y\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import precision_recall_curve, average_precision_score\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class precision-recall curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute precision-recall curve for each class\nprecision = dict()\nrecall = dict()\naverage_precision = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    precision[i], recall[i], _ = precision_recall_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    average_precision[i] = average_precision_score(all_labels_bin[:, i], all_preds_bin[:, i])\n\n# Compute micro-average precision-recall curve\nprecision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\naverage_precision[\"micro\"] = average_precision_score(all_labels_bin, all_preds_bin, average=\"micro\")\n\n# Plot precision-recall curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        recall[i],\n        precision[i],\n        label=f\"Class {i} (AP = {average_precision[i]:.2f})\",\n    )\n\n# Plot micro-average precision-recall curve\nplt.plot(\n    recall[\"micro\"],\n    precision[\"micro\"],\n    label=f\"Micro-Average (AP = {average_precision['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.xlabel(\"Recall\")\nplt.ylabel(\"Precision\")\nplt.title(\"Precision-Recall Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower left\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import roc_curve, auc\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class ROC curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute ROC curve and AUC for each class\nfpr = dict()\ntpr = dict()\nroc_auc = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    fpr[i], tpr[i], _ = roc_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    roc_auc[i] = auc(fpr[i], tpr[i])\n\n# Compute micro-average ROC curve and AUC\nfpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\nroc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n# Plot ROC curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        fpr[i],\n        tpr[i],\n        label=f\"Class {i} (AUC = {roc_auc[i]:.2f})\",\n    )\n\n# Plot micro-average ROC curve\nplt.plot(\n    fpr[\"micro\"],\n    tpr[\"micro\"],\n    label=f\"Micro-Average (AUC = {roc_auc['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.plot([0, 1], [0, 1], color=\"gray\", linestyle=\"--\")  # Diagonal line\nplt.xlabel(\"False Positive Rate\")\nplt.ylabel(\"True Positive Rate\")\nplt.title(\"Receiver Operating Characteristic (ROC) Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower right\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Aptos","metadata":{}},{"cell_type":"code","source":"# Define dataset paths\nimage_dir = \"/kaggle/input/aptos2019-blindness-detection/train_images\"\ncsv_file = \"/kaggle/input/aptos2019-blindness-detection/train.csv\"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define image transformations\ntransform = transforms.Compose([\n    transforms.Resize((224, 224)),  # Resize images to match model input\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define dataset class\nclass APTOSDataset(Dataset):\n    def __init__(self, image_dir, csv_file, transform=None):\n        self.image_dir = image_dir\n        self.transform = transform\n        self.df = pd.read_csv(csv_file)\n\n        # Ensure column names are correctly read\n        self.df.columns = self.df.columns.str.strip()\n\n    def __len__(self):\n        return len(self.df)\n\n    def __getitem__(self, idx):\n        # Extract image ID and label\n        img_id = self.df.iloc[idx][\"id_code\"]\n        label = self.df.iloc[idx][\"diagnosis\"]  # Use the original class label (0 to 4)\n\n        # Load image\n        img_path = os.path.join(self.image_dir, img_id + \".png\")\n        try:\n            image = Image.open(img_path).convert(\"RGB\")\n        except Exception as e:\n            print(f\"Error loading image {img_path}: {e}\")\n            return None, None\n\n        # Apply transformations\n        if self.transform:\n            image = self.transform(image)\n\n        return image, label","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Create dataset and dataloader\nbatch_size = 64\ntest_dataset = APTOSDataset(image_dir=image_dir, csv_file=csv_file, transform=transform)\ntest_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Run evaluation\nall_labels, all_preds = evaluate_model(model, test_loader)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import confusion_matrix\n\n# Compute confusion matrix\ncm = confusion_matrix(all_labels, all_preds)\n\n# Plot confusion matrix\nplt.figure(figsize=(8, 7))  # Adjust figure size for better readability\nsns.heatmap(\n    cm, \n    annot=True, \n    fmt=\"d\", \n    cmap=\"Blues\", \n    xticklabels=[f\"Class {i}\" for i in range(5)],  # Labels for predicted classes\n    yticklabels=[f\"Class {i}\" for i in range(5)]   # Labels for true classes\n)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"True Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\n\n# Convert predictions to numpy for histogram\nall_preds = np.array(all_preds)\n\n# Define the number of classes\nnum_classes = 5  # Classes: 0, 1, 2, 3, 4\n\nplt.figure(figsize=(8, 6))  # Adjust figure size for better readability\nplt.hist(\n    all_preds, \n    bins=np.arange(-0.5, num_classes + 0.5, 1),  # Bin edges for class indices\n    edgecolor='black', \n    alpha=0.7, \n    color='blue'\n)\nplt.xticks(range(num_classes), labels=[f\"Class {i}\" for i in range(num_classes)])  # Labels for classes\nplt.xlabel(\"Predicted Class\")\nplt.ylabel(\"Count\")\nplt.title(\"Distribution of Predictions\")\nplt.grid(axis=\"y\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import precision_recall_curve, average_precision_score\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class precision-recall curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute precision-recall curve for each class\nprecision = dict()\nrecall = dict()\naverage_precision = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    precision[i], recall[i], _ = precision_recall_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    average_precision[i] = average_precision_score(all_labels_bin[:, i], all_preds_bin[:, i])\n\n# Compute micro-average precision-recall curve\nprecision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\naverage_precision[\"micro\"] = average_precision_score(all_labels_bin, all_preds_bin, average=\"micro\")\n\n# Plot precision-recall curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        recall[i],\n        precision[i],\n        label=f\"Class {i} (AP = {average_precision[i]:.2f})\",\n    )\n\n# Plot micro-average precision-recall curve\nplt.plot(\n    recall[\"micro\"],\n    precision[\"micro\"],\n    label=f\"Micro-Average (AP = {average_precision['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.xlabel(\"Recall\")\nplt.ylabel(\"Precision\")\nplt.title(\"Precision-Recall Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower left\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import roc_curve, auc\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class ROC curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute ROC curve and AUC for each class\nfpr = dict()\ntpr = dict()\nroc_auc = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    fpr[i], tpr[i], _ = roc_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    roc_auc[i] = auc(fpr[i], tpr[i])\n\n# Compute micro-average ROC curve and AUC\nfpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\nroc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n# Plot ROC curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        fpr[i],\n        tpr[i],\n        label=f\"Class {i} (AUC = {roc_auc[i]:.2f})\",\n    )\n\n# Plot micro-average ROC curve\nplt.plot(\n    fpr[\"micro\"],\n    tpr[\"micro\"],\n    label=f\"Micro-Average (AUC = {roc_auc['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.plot([0, 1], [0, 1], color=\"gray\", linestyle=\"--\")  # Diagonal line\nplt.xlabel(\"False Positive Rate\")\nplt.ylabel(\"True Positive Rate\")\nplt.title(\"Receiver Operating Characteristic (ROC) Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower right\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Messidor2","metadata":{}},{"cell_type":"code","source":"import os\nimport pandas as pd\nimport torch\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\nfrom PIL import Image\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom sklearn.metrics import confusion_matrix, classification_report\n\n# Define image transformations\ntransform = transforms.Compose([\n    transforms.Resize((224, 224)),  # Resize to match model input\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n])\n\n# Correct paths\ncsv_path = \"/kaggle/input/messidor2-dr-grades/messidor_data.csv\"\nimg_folder = \"/kaggle/input/messifor2/messidor2/IMAGES\"\n\n# Load CSV file\nMessidor2_data = pd.read_csv(csv_path)\n\n# Ensure correct data types and drop missing labels\nMessidor2_data = Messidor2_data.dropna(subset=[\"adjudicated_dr_grade\"])  # Drop NaNs\nMessidor2_data[\"adjudicated_dr_grade\"] = Messidor2_data[\"adjudicated_dr_grade\"].astype(int)  # Ensure integer labels\n\nclass MessidorDataset(Dataset):\n    def __init__(self, dataframe, root_dir, transform=None):\n        self.data = dataframe\n        self.root_dir = root_dir\n        self.transform = transform\n\n        # Ensure image_id column has \".png\" extension\n        self.data[\"image_id\"] = self.data[\"image_id\"].astype(str).apply(lambda x: x if x.endswith(\".png\") else x + \".png\")\n\n        # Get valid image files in the folder\n        self.valid_images = set(os.listdir(root_dir))\n\n        # Filter dataset to include only existing images\n        self.data = self.data[self.data[\"image_id\"].isin(self.valid_images)].reset_index(drop=True)\n\n    def __len__(self):\n        return len(self.data)\n\n    def __getitem__(self, idx):\n        img_name = self.data.iloc[idx][\"image_id\"]\n        img_path = os.path.join(self.root_dir, img_name)\n\n        # Load image\n        try:\n            image = Image.open(img_path).convert(\"RGB\")\n        except Exception as e:\n            print(f\"Error loading image {img_path}: {e}\")\n            return None, None\n\n        # Extract label as multi-class classification\n        label = int(self.data.iloc[idx][\"adjudicated_dr_grade\"])  # Use original class labels (0 to 4)\n\n        # Apply transformations\n        if self.transform:\n            image = self.transform(image)\n\n        return image, torch.tensor(label, dtype=torch.long)  # CrossEntropyLoss expects long labels\n\n# Create dataset and dataloader\ntest_dataset = MessidorDataset(Messidor2_data, img_folder, transform=transform)\ntest_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)\n\nprint(f\"Total images found: {len(test_dataset)}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Load trained model\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel.to(device)\nmodel.eval()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import cohen_kappa_score\n\n# Evaluate model\ndef evaluate_multiclass_model(model, dataloader):\n    model.eval()\n    all_labels, all_preds = [], []\n\n    with torch.no_grad():\n        for images, labels in dataloader:\n            images, labels = images.to(device), labels.to(device)\n\n            outputs = model(images)\n            _, preds = torch.max(outputs, 1)  # Get predicted class indices\n\n            all_labels.extend(labels.cpu().numpy())\n            all_preds.extend(preds.cpu().numpy())\n\n    return all_labels, all_preds\n\n# Run evaluation\nall_labels, all_preds = evaluate_multiclass_model(model, test_loader)\n\n# Compute multi-class confusion matrix\ncm = confusion_matrix(all_labels, all_preds)\nprint(\"Confusion Matrix:\\n\", cm)\n\n# Classification Report\nprint(\"Classification Report:\\n\", classification_report(\n    all_labels, \n    all_preds, \n    target_names=[f\"Class {i}\" for i in range(5)]  # Adjust for 5 classes\n))\n\n# Compute Quadratic Weighted Kappa (QWK)\nqwk = cohen_kappa_score(all_labels, all_preds, weights='quadratic')\nprint(f\"Quadratic Weighted Kappa (QWK): {qwk:.4f}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import confusion_matrix\n\n# Compute confusion matrix\ncm = confusion_matrix(all_labels, all_preds)\n\n# Plot confusion matrix\nplt.figure(figsize=(8, 7))  # Adjust figure size for better readability\nsns.heatmap(\n    cm, \n    annot=True, \n    fmt=\"d\", \n    cmap=\"Blues\", \n    xticklabels=[f\"Class {i}\" for i in range(5)],  # Labels for predicted classes\n    yticklabels=[f\"Class {i}\" for i in range(5)]   # Labels for true classes\n)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"True Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\n\n# Convert predictions to numpy for histogram\nall_preds = np.array(all_preds)\n\n# Define the number of classes\nnum_classes = 5  # Classes: 0, 1, 2, 3, 4\n\nplt.figure(figsize=(8, 6))  # Adjust figure size for better readability\nplt.hist(\n    all_preds, \n    bins=np.arange(-0.5, num_classes + 0.5, 1),  # Bin edges for class indices\n    edgecolor='black', \n    alpha=0.7, \n    color='blue'\n)\nplt.xticks(range(num_classes), labels=[f\"Class {i}\" for i in range(num_classes)])  # Labels for classes\nplt.xlabel(\"Predicted Class\")\nplt.ylabel(\"Count\")\nplt.title(\"Distribution of Predictions\")\nplt.grid(axis=\"y\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import precision_recall_curve, average_precision_score\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class precision-recall curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute precision-recall curve for each class\nprecision = dict()\nrecall = dict()\naverage_precision = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    precision[i], recall[i], _ = precision_recall_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    average_precision[i] = average_precision_score(all_labels_bin[:, i], all_preds_bin[:, i])\n\n# Compute micro-average precision-recall curve\nprecision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\naverage_precision[\"micro\"] = average_precision_score(all_labels_bin, all_preds_bin, average=\"micro\")\n\n# Plot precision-recall curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        recall[i],\n        precision[i],\n        label=f\"Class {i} (AP = {average_precision[i]:.2f})\",\n    )\n\n# Plot micro-average precision-recall curve\nplt.plot(\n    recall[\"micro\"],\n    precision[\"micro\"],\n    label=f\"Micro-Average (AP = {average_precision['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.xlabel(\"Recall\")\nplt.ylabel(\"Precision\")\nplt.title(\"Precision-Recall Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower left\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import roc_curve, auc\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class ROC curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute ROC curve and AUC for each class\nfpr = dict()\ntpr = dict()\nroc_auc = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    fpr[i], tpr[i], _ = roc_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    roc_auc[i] = auc(fpr[i], tpr[i])\n\n# Compute micro-average ROC curve and AUC\nfpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\nroc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n# Plot ROC curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        fpr[i],\n        tpr[i],\n        label=f\"Class {i} (AUC = {roc_auc[i]:.2f})\",\n    )\n\n# Plot micro-average ROC curve\nplt.plot(\n    fpr[\"micro\"],\n    tpr[\"micro\"],\n    label=f\"Micro-Average (AUC = {roc_auc['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.plot([0, 1], [0, 1], color=\"gray\", linestyle=\"--\")  # Diagonal line\nplt.xlabel(\"False Positive Rate\")\nplt.ylabel(\"True Positive Rate\")\nplt.title(\"Receiver Operating Characteristic (ROC) Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower right\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# DDR","metadata":{}},{"cell_type":"code","source":"import pandas as pd\n\n# Set path to DDR dataset\nDDR_DIR = \"/kaggle/input/idriddiseasegrading/DDR-dataset/DR_grading\"\nTEST_CSV = f\"{DDR_DIR}/test.csv\"\n\n# Load test.csv\ndf_test = pd.read_csv(TEST_CSV)\n\n# Ensure 'Retinopathy grade' column contains valid integer labels\ndf_test = df_test.dropna(subset=[\"Retinopathy grade\"])  # Drop rows with missing labels\ndf_test[\"Retinopathy grade\"] = df_test[\"Retinopathy grade\"].astype(int)  # Ensure integer type\n\n# Display dataset preview\nprint(df_test.head())","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nfrom PIL import Image\nimport torch\nfrom torch.utils.data import Dataset\nimport torchvision.transforms as transforms\n\nclass DDRDataset(Dataset):\n    def __init__(self, df, img_dir, transform=None):\n        self.df = df\n        self.img_dir = img_dir\n        self.transform = transform\n\n        # Filter out rows with label 5 (ignore class 5)\n        self.df = self.df[self.df['Retinopathy grade'] != 5].reset_index(drop=True)\n\n    def __len__(self):\n        return len(self.df)\n\n    def __getitem__(self, idx):\n        # Get image file name and corresponding label\n        img_id = str(self.df.iloc[idx]['Image name'])\n        img_path = os.path.join(self.img_dir, img_id)\n        label = int(self.df.iloc[idx]['Retinopathy grade'])  # Use original multi-class labels (0 to 4)\n\n        # Load and preprocess image\n        try:\n            image = Image.open(img_path).convert(\"RGB\")\n        except Exception as e:\n            print(f\"Error loading image {img_path}: {e}\")\n            return None, None\n\n        if self.transform:\n            image = self.transform(image)\n\n        return image, label\n\n# Define transformation (resize to match model input)\ntest_transforms = transforms.Compose([\n    transforms.Resize((224, 224)),  # Adjust based on your model input size\n    transforms.ToTensor(),\n    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Standard normalization for ImageNet\n])\n\n# Set path to DDR test images\nDDR_TEST_IMG_DIR = f\"{DDR_DIR}/test\"\n\n# Create dataset\ntest_dataset = DDRDataset(df_test, DDR_TEST_IMG_DIR, transform=test_transforms)\n\n# Create DataLoader\ntest_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)\n\nprint(\"DDR Test DataLoader Ready!\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import cohen_kappa_score, confusion_matrix, classification_report\n\n# Evaluate model\nall_labels = []\nall_preds = []\n\nwith torch.no_grad():\n    for images, labels in test_loader:\n        images, labels = images.to(device), labels.to(device)\n\n        # Forward pass\n        outputs = model(images)\n        _, preds = torch.max(outputs, 1)  # Get predicted class indices\n\n        # Store results\n        all_labels.extend(labels.cpu().numpy())\n        all_preds.extend(preds.cpu().numpy())\n\n# Compute metrics\naccuracy = sum([1 for l, p in zip(all_labels, all_preds) if l == p]) / len(all_labels) * 100\nqwk = cohen_kappa_score(all_labels, all_preds, weights='quadratic')\n\n# Confusion Matrix\ncm = confusion_matrix(all_labels, all_preds)\n\n# Classification Report\nreport = classification_report(\n    all_labels,\n    all_preds,\n    target_names=[f\"Class {i}\" for i in range(5)],  # Adjust for 5 classes\n    output_dict=False\n)\n\n# Print results\nprint(f\"Model Accuracy on DDR Test Data: {accuracy:.2f}%\")\nprint(f\"Quadratic Weighted Kappa (QWK): {qwk:.4f}\")\nprint(\"Confusion Matrix:\\n\", cm)\nprint(\"Classification Report:\\n\", report)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import confusion_matrix\n\n# Compute confusion matrix\ncm = confusion_matrix(all_labels, all_preds)\n\n# Plot confusion matrix\nplt.figure(figsize=(8, 7))  # Adjust figure size for better readability\nsns.heatmap(\n    cm, \n    annot=True, \n    fmt=\"d\", \n    cmap=\"Blues\", \n    xticklabels=[f\"Class {i}\" for i in range(5)],  # Labels for predicted classes\n    yticklabels=[f\"Class {i}\" for i in range(5)]   # Labels for true classes\n)\nplt.xlabel(\"Predicted Label\")\nplt.ylabel(\"True Label\")\nplt.title(\"Confusion Matrix\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\n\n# Convert predictions to numpy for histogram\nall_preds = np.array(all_preds)\n\n# Define the number of classes\nnum_classes = 5  # Classes: 0, 1, 2, 3, 4\n\nplt.figure(figsize=(8, 6))  # Adjust figure size for better readability\nplt.hist(\n    all_preds, \n    bins=np.arange(-0.5, num_classes + 0.5, 1),  # Bin edges for class indices\n    edgecolor='black', \n    alpha=0.7, \n    color='blue'\n)\nplt.xticks(range(num_classes), labels=[f\"Class {i}\" for i in range(num_classes)])  # Labels for classes\nplt.xlabel(\"Predicted Class\")\nplt.ylabel(\"Count\")\nplt.title(\"Distribution of Predictions\")\nplt.grid(axis=\"y\")\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import precision_recall_curve, average_precision_score\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class precision-recall curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute precision-recall curve for each class\nprecision = dict()\nrecall = dict()\naverage_precision = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    precision[i], recall[i], _ = precision_recall_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    average_precision[i] = average_precision_score(all_labels_bin[:, i], all_preds_bin[:, i])\n\n# Compute micro-average precision-recall curve\nprecision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\naverage_precision[\"micro\"] = average_precision_score(all_labels_bin, all_preds_bin, average=\"micro\")\n\n# Plot precision-recall curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        recall[i],\n        precision[i],\n        label=f\"Class {i} (AP = {average_precision[i]:.2f})\",\n    )\n\n# Plot micro-average precision-recall curve\nplt.plot(\n    recall[\"micro\"],\n    precision[\"micro\"],\n    label=f\"Micro-Average (AP = {average_precision['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.xlabel(\"Recall\")\nplt.ylabel(\"Precision\")\nplt.title(\"Precision-Recall Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower left\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import roc_curve, auc\nfrom sklearn.preprocessing import label_binarize\nimport numpy as np\n\n# Binarize the labels for multi-class ROC curve\nall_labels_bin = label_binarize(all_labels, classes=[0, 1, 2, 3, 4])  # One-hot encode true labels\nall_preds_bin = label_binarize(all_preds, classes=[0, 1, 2, 3, 4])    # One-hot encode predicted labels\n\n# Compute ROC curve and AUC for each class\nfpr = dict()\ntpr = dict()\nroc_auc = dict()\n\nn_classes = all_labels_bin.shape[1]  # Number of classes\n\nfor i in range(n_classes):\n    fpr[i], tpr[i], _ = roc_curve(all_labels_bin[:, i], all_preds_bin[:, i])\n    roc_auc[i] = auc(fpr[i], tpr[i])\n\n# Compute micro-average ROC curve and AUC\nfpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(\n    all_labels_bin.ravel(), all_preds_bin.ravel()\n)\nroc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n\n# Plot ROC curves\nplt.figure(figsize=(8, 6))\nfor i in range(n_classes):\n    plt.plot(\n        fpr[i],\n        tpr[i],\n        label=f\"Class {i} (AUC = {roc_auc[i]:.2f})\",\n    )\n\n# Plot micro-average ROC curve\nplt.plot(\n    fpr[\"micro\"],\n    tpr[\"micro\"],\n    label=f\"Micro-Average (AUC = {roc_auc['micro']:.2f})\",\n    linestyle=\"--\",\n    linewidth=2,\n)\n\nplt.plot([0, 1], [0, 1], color=\"gray\", linestyle=\"--\")  # Diagonal line\nplt.xlabel(\"False Positive Rate\")\nplt.ylabel(\"True Positive Rate\")\nplt.title(\"Receiver Operating Characteristic (ROC) Curve (One-vs-Rest)\")\nplt.legend(loc=\"lower right\")\nplt.grid()\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}