{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":52254,"databundleVersionId":9674523,"sourceType":"competition"},{"sourceId":6331238,"sourceType":"datasetVersion","datasetId":3644255}],"dockerImageVersionId":30528,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# import packages\nimport os\nimport pickle\nfrom tqdm.notebook import tqdm\nimport random\nfrom tabulate import tabulate\n\nimport cv2\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport numpy as np\nimport pandas as pd\nimport pydicom\nimport matplotlib.pyplot as plt\nimport torchvision.transforms.v2 as t\n\nfrom sklearn.model_selection import KFold, StratifiedKFold\nfrom sklearn.metrics import accuracy_score, roc_auc_score\nfrom torch.utils.data import Dataset, DataLoader, Subset\nfrom torch.optim.lr_scheduler import ReduceLROnPlateau\nfrom torch.optim import Adam\nfrom torchvision import models\nfrom torchvision.transforms.v2 import Resize, Compose, RandomHorizontalFlip, ColorJitter, RandomAffine, RandomErasing, ToTensor","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-11-18T23:08:13.585591Z","iopub.execute_input":"2024-11-18T23:08:13.585858Z","iopub.status.idle":"2024-11-18T23:08:17.328282Z","shell.execute_reply.started":"2024-11-18T23:08:13.585835Z","shell.execute_reply":"2024-11-18T23:08:17.32757Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"TRAIN_IMG_PATH = '/kaggle/input/rsna-2023-atd-reduced-256-5mm/reduced_256_tickness_5'\nTEST_IMG_PATH = '/kaggle/input/rsna-2023-abdominal-trauma-detection/test_images'\nTRAIN_DF_PATH = '/kaggle/input/rsna-2023-abdominal-trauma-detection/train.csv'","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.32972Z","iopub.execute_input":"2024-11-18T23:08:17.330186Z","iopub.status.idle":"2024-11-18T23:08:17.334171Z","shell.execute_reply.started":"2024-11-18T23:08:17.330159Z","shell.execute_reply":"2024-11-18T23:08:17.333274Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def fetch_img_paths(train_img_path):\n    img_paths = []\n    \n    print('Scanning directories...')\n    for patient in tqdm(os.listdir(train_img_path)):\n        for scan in os.listdir(os.path.join(TRAIN_IMG_PATH, patient)):\n            scans = []\n            for img in os.listdir(os.path.join(TRAIN_IMG_PATH, patient, scan)):\n                scans.append(os.path.join(TRAIN_IMG_PATH, patient, scan, img))\n            \n            img_paths.append(scans)\n            \n    return img_paths","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.335089Z","iopub.execute_input":"2024-11-18T23:08:17.335369Z","iopub.status.idle":"2024-11-18T23:08:17.343113Z","shell.execute_reply.started":"2024-11-18T23:08:17.335347Z","shell.execute_reply":"2024-11-18T23:08:17.342396Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def select_elements_with_spacing(input_list, spacing):\n    \n    \"\"\"\n    Selects elements with a specified spacing from a given list.\n\n    Args:\n        input_list (list): The input list from which elements will be selected.\n        spacing (int): The spacing between selected elements.\n\n    Returns:\n        list: A list of selected elements from the input list.\n\n    Raises:\n        ValueError: If the input list does not contain at least 4 * spacing elements.\n    \"\"\"\n \n    if len(input_list) < spacing * 4:\n        raise ValueError(\"List should contain at least 4 * spacing elements.\")\n        \n        \n    # We want to select elements in the middle part of the abdomen\n    lower_bound = int(len(input_list) * 0.4)\n    upper_bound = int(len(input_list) * 0.6)\n\n    spacing = (upper_bound - lower_bound) // 3\n    \n    # start_index = random.randint(lower_bound, upper_bound)\n    \n    selected_indices = [lower_bound, lower_bound + spacing, lower_bound + (2*spacing), upper_bound]\n    \n    selected_elements = [input_list[index] for index in selected_indices]\n    \n    return selected_elements","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.344869Z","iopub.execute_input":"2024-11-18T23:08:17.345102Z","iopub.status.idle":"2024-11-18T23:08:17.353057Z","shell.execute_reply.started":"2024-11-18T23:08:17.345073Z","shell.execute_reply":"2024-11-18T23:08:17.352292Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def standardize_pixel_array(dicom_image):\n    \"\"\"\n    Standardizes a DICOM pixel array by applying various transformations.\n    \n    Args:\n        dicom_path (str): Path to the DICOM image file.\n        \n    Returns:\n        np.ndarray: The standardized pixel array of the DICOM image.\n    \"\"\"\n    pixel_array = dicom_image.pixel_array\n    \n    if dicom_image.PixelRepresentation == 1:\n        bit_shift = dicom_image.BitsAllocated - dicom_image.BitsStored\n        dtype = pixel_array.dtype \n        new_array = (pixel_array << bit_shift).astype(dtype) >>  bit_shift\n        pixel_array = pydicom.pixel_data_handlers.util.apply_modality_lut(new_array, dicom_image)\n\n    if dicom_image.PhotometricInterpretation == \"MONOCHROME1\":\n        pixel_array = 1 - pixel_array\n\n    # transform to hounsfield units\n    intercept = dicom_image.RescaleIntercept\n    slope = dicom_image.RescaleSlope\n    pixel_array = pixel_array * slope + intercept\n\n    # windowing\n    window_center = int(dicom_image.WindowCenter)\n    window_width = int(dicom_image.WindowWidth)\n    img_min = window_center - window_width // 2\n    img_max = window_center + window_width // 2\n    pixel_array = pixel_array.copy()\n    pixel_array[pixel_array < img_min] = img_min\n    pixel_array[pixel_array > img_max] = img_max\n\n    # normalization\n    if pixel_array.max() == pixel_array.min():\n        pixel_array = np.zeros_like(pixel_array)  # Handle case of constant array\n    else:\n        pixel_array = (pixel_array - pixel_array.min()) / (pixel_array.max() - pixel_array.min())\n\n    return pixel_array","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.353952Z","iopub.execute_input":"2024-11-18T23:08:17.354189Z","iopub.status.idle":"2024-11-18T23:08:17.365265Z","shell.execute_reply.started":"2024-11-18T23:08:17.354169Z","shell.execute_reply":"2024-11-18T23:08:17.364578Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def preprocess_jpeg(jpeg_path):\n    \n    img = cv2.imread(jpeg_path)\n    greyscale = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)/255\n    \n    return greyscale","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.366296Z","iopub.execute_input":"2024-11-18T23:08:17.366848Z","iopub.status.idle":"2024-11-18T23:08:17.375144Z","shell.execute_reply.started":"2024-11-18T23:08:17.366818Z","shell.execute_reply":"2024-11-18T23:08:17.374519Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# dataset\nclass AbdominalData(Dataset):\n    \"\"\"\n    Custom dataset class for handling abdominal trauma data classification.\n    \n    Args:\n        df_path (str): Path to the CSV file containing patient labels.\n        current_fold (int): The current fold for cross-validation.\n        num_fold (int, optional): Total number of folds for cross-validation. Default is 5.\n    \"\"\"\n    \n    def __init__(self, df_path, current_fold, num_fold = 5):\n        \n        super().__init__()\n        \n        # collect all the image instance paths\n        self.img_paths = fetch_img_paths(TRAIN_IMG_PATH)\n                \n        self.df = pd.read_csv(df_path)\n        \n        self.num_fold = num_fold\n        self.current_fold = current_fold\n        self.kf = KFold(n_splits=num_fold)\n        \n        self.transform = Compose([\n#                             Resize((256, 256), antialias=True),\n                            RandomHorizontalFlip(),  # Randomly flip images left-right\n                            ColorJitter(brightness=0.2),  # Randomly adjust brightness\n                            ColorJitter(contrast=0.2),  # Randomly adjust contrast\n                            RandomAffine(degrees=0, shear=10),  # Apply shear transformation\n                            RandomAffine(degrees=0, scale=(0.8, 1.2)),  # Apply zoom transformation\n                            RandomErasing(p=0.2, scale=(0.02, 0.2)), # Coarse dropout\n                            ToTensor(),\n                        ])\n    \n    def __len__(self):\n        \"\"\"\n        Returns the total number of samples in the dataset.\n        \"\"\"\n        \n        return len(self.img_paths)\n    \n    def __getitem__(self, idx):\n        \"\"\"\n        Retrieves a sample from the dataset by index.\n        \n        Args:\n            idx (int): Index of the dataset to retrieve.\n        \n        Returns:\n            dict: A dictionary containing the image data and labels for different abdominal structures.\n        \"\"\"\n        \n        # sample 4 image instances\n        dicom_images = select_elements_with_spacing(self.img_paths[idx],\n                                                    spacing = 2)\n        patient_id = dicom_images[0].split('/')[-3]\n        images = []\n        \n        for d in dicom_images:\n            image = preprocess_jpeg(d)\n            images.append(image)\n            \n        images = np.stack(images)\n        image = torch.tensor(images, dtype = torch.float).unsqueeze(dim = 1)\n        \n        image = self.transform(image).squeeze(dim = 1)\n        \n        label = self.df[self.df.patient_id == int(patient_id)].values[0][1:-1]\n        \n        # labels\n        bowel = np.argmax(label[0:2], keepdims = True)\n        extravasation = np.argmax(label[2:4], keepdims = True)\n        kidney = np.argmax(label[4:7], keepdims = False)\n        liver = np.argmax(label[7:10], keepdims = False)\n        spleen = np.argmax(label[10:], keepdims = False)\n        \n        \n        return {\n            'image': image,\n            'bowel': bowel,\n            'extravasation': extravasation,\n            'kidney': kidney,\n            'liver': liver,\n            'spleen': spleen,\n        }\n    \n    def get_splits(self):\n        \"\"\"\n        Splits the dataset into training and validation subsets based on the current fold.\n        \n        Returns:\n            tuple: A tuple containing the training and validation subsets.\n        \"\"\"\n        \n        fold_data = list(self.kf.split(self.img_paths))\n        train_indices, val_indices = fold_data[self.current_fold]\n\n        train_data = self._get_subset(train_indices)\n        val_data = self._get_subset(val_indices)\n        \n        return train_data, val_data\n\n    def _get_subset(self, indices):\n        \"\"\"\n        Returns a subset of the dataset based on the provided indices.\n        \n        Args:\n            indices (list): List of indices to include in the subset.\n        \n        Returns:\n            Subset: A subset of the dataset.\n        \"\"\"\n        return Subset(self, indices)","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.376256Z","iopub.execute_input":"2024-11-18T23:08:17.376572Z","iopub.status.idle":"2024-11-18T23:08:17.387891Z","shell.execute_reply.started":"2024-11-18T23:08:17.376542Z","shell.execute_reply":"2024-11-18T23:08:17.387012Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class MetricsCalculator:\n    \n    def __init__(self, mode = 'binary'):\n        \n        self.probabilities = []\n        self.predictions = []\n        self.targets = []\n        \n        self.mode = mode\n    \n    def update(self, logits, target):\n        \"\"\"\n        Update the metrics calculator with predicted values and corresponding targets.\n        \n        Args:\n            predicted (torch.Tensor): Predicted values.\n            target (torch.Tensor): Ground truth targets.\n        \"\"\"\n        if self.mode == 'binary':\n            probabilities = torch.sigmoid(logits)\n            predicted = (probabilities > 0.5)\n        else:\n            probabilities = F.softmax(logits, dim = 1)\n            predicted = torch.argmax(probabilities, dim=1)\n            \n        self.probabilities.extend(probabilities.detach().cpu().numpy())\n        self.predictions.extend(predicted.detach().cpu().numpy())\n        self.targets.extend(target.detach().cpu().numpy())\n    \n    def reset(self):\n        \"\"\"Reset the stored predictions and targets.\"\"\"\n        \n        self.probabilities = []\n        self.predictions = []\n        self.targets = []\n    \n    def compute_accuracy(self):\n        \"\"\"\n        Compute the accuracy metric.\n        \n        Returns:\n            float: Accuracy.\n        \"\"\"\n        return accuracy_score(self.targets, self.predictions)\n    \n    def compute_auc(self):\n        \"\"\"\n        Compute the AUC (Area Under the Curve) metric.\n        \n        Returns:\n            float: AUC.\n        \"\"\"\n        if self.mode == 'multi':\n            return roc_auc_score(self.targets, self.probabilities, multi_class = 'ovo', labels=[0, 1, 2])\n    \n        else:\n            return roc_auc_score(self.targets, self.probabilities)","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.388877Z","iopub.execute_input":"2024-11-18T23:08:17.389183Z","iopub.status.idle":"2024-11-18T23:08:17.399848Z","shell.execute_reply.started":"2024-11-18T23:08:17.389153Z","shell.execute_reply":"2024-11-18T23:08:17.39915Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nfrom torchvision import models\n\n# Define the AttentionLayer class or import it\nclass AttentionLayer(nn.Module):\n    def __init__(self, num_channels):\n        super(AttentionLayer, self).__init__()\n        self.attention = nn.Sequential(\n            nn.Conv2d(num_channels, num_channels // 8, 1),\n            nn.ReLU(),\n            nn.Conv2d(num_channels // 8, num_channels, 1),\n            nn.Sigmoid()\n        )\n\n    def forward(self, x):\n        return x * self.attention(x)\n\n# Define the CNNModel\nclass CNNModel(nn.Module):\n    def __init__(self):\n        super().__init__()\n\n        self.input = nn.Conv2d(4, 3, kernel_size=3)\n        model = models.efficientnet_b0(weights='IMAGENET1K_V1')\n\n        self.features = model.features\n        self.avgpool = model.avgpool\n\n        # Adding the Attention Layer\n        self.attention = AttentionLayer(1280)  # The number of channels at this point\n\n        # Multi-output classification\n        self.bowel = nn.Linear(1280, 1)\n        self.extravasation = nn.Linear(1280, 1)\n        self.kidney = nn.Linear(1280, 3)\n        self.liver = nn.Linear(1280, 3)\n        self.spleen = nn.Linear(1280, 3)\n\n    def forward(self, x):\n        # Extract features\n        x = self.input(x)\n        x = self.features(x)\n\n        # Attention mechanism\n        x = self.attention(x)\n\n        x = self.avgpool(x)\n        x = torch.flatten(x, 1)\n\n        # Output logits\n        bowel = self.bowel(x)\n        extravasation = self.extravasation(x)\n        kidney = self.kidney(x)\n        liver = self.liver(x)\n        spleen = self.spleen(x)\n\n        return bowel, extravasation, kidney, liver, spleen\n\n","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.400812Z","iopub.execute_input":"2024-11-18T23:08:17.401042Z","iopub.status.idle":"2024-11-18T23:08:17.41098Z","shell.execute_reply.started":"2024-11-18T23:08:17.401022Z","shell.execute_reply":"2024-11-18T23:08:17.410256Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Tạo mô hình và chuyển nó lên GPU\nmodel = CNNModel().to('cuda')\n","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:17.414594Z","iopub.execute_input":"2024-11-18T23:08:17.415344Z","iopub.status.idle":"2024-11-18T23:08:18.129563Z","shell.execute_reply.started":"2024-11-18T23:08:17.415314Z","shell.execute_reply":"2024-11-18T23:08:18.128647Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"BATCH_SIZE = 16\nNUM_EPOCHS = 200\nLR = 1e-4","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:18.130672Z","iopub.execute_input":"2024-11-18T23:08:18.13093Z","iopub.status.idle":"2024-11-18T23:08:18.135013Z","shell.execute_reply.started":"2024-11-18T23:08:18.130908Z","shell.execute_reply":"2024-11-18T23:08:18.134146Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def get_data_loaders(fold: int, batch_size: int):\n    # Get the data splits for the given fold\n    train_data, val_data = AbdominalData('/kaggle/input/rsna-2023-abdominal-trauma-detection/train_2024.csv', current_fold=fold).get_splits()\n    \n    # Create and return train and validation data loaders\n    return (\n        DataLoader(train_data, batch_size=batch_size, shuffle=True),\n        DataLoader(val_data, batch_size=batch_size, shuffle=False)\n    )\n\n# Now, to get the data loaders for a specific fold, you can call:\ntrain_dataloader_0, val_dataloader_0 = get_data_loaders(0, BATCH_SIZE)\ntrain_dataloader_1, val_dataloader_1 = get_data_loaders(1, BATCH_SIZE)\ntrain_dataloader_2, val_dataloader_2 = get_data_loaders(2, BATCH_SIZE)\ntrain_dataloader_3, val_dataloader_3 = get_data_loaders(3, BATCH_SIZE)\ntrain_dataloader_4, val_dataloader_4 = get_data_loaders(4, BATCH_SIZE)\n","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:08:18.136244Z","iopub.execute_input":"2024-11-18T23:08:18.136477Z","iopub.status.idle":"2024-11-18T23:10:00.952071Z","shell.execute_reply.started":"2024-11-18T23:08:18.136457Z","shell.execute_reply":"2024-11-18T23:10:00.951193Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_data_0, val_data_0 = AbdominalData('/kaggle/input/rsna-2023-abdominal-trauma-detection/train_2024.csv', current_fold=0).get_splits()\ntrain_data_1, val_data_1 = AbdominalData('/kaggle/input/rsna-2023-abdominal-trauma-detection/train_2024.csv', current_fold=1).get_splits()\ntrain_data_2, val_data_2 = AbdominalData('/kaggle/input/rsna-2023-abdominal-trauma-detection/train_2024.csv', current_fold=2).get_splits()\ntrain_data_3, val_data_3 = AbdominalData('/kaggle/input/rsna-2023-abdominal-trauma-detection/train_2024.csv', current_fold=3).get_splits()\ntrain_data_4, val_data_4 = AbdominalData('/kaggle/input/rsna-2023-abdominal-trauma-detection/train_2024.csv', current_fold=4).get_splits()\n\ntrain_dataloader_0 = DataLoader(train_data_0,batch_size = BATCH_SIZE, shuffle = True)\nval_dataloader_0 = DataLoader(val_data_0,batch_size = BATCH_SIZE, shuffle = False)\ntrain_dataloader_1 = DataLoader(train_data_1,batch_size = BATCH_SIZE, shuffle = True)\nval_dataloader_1 = DataLoader(val_data_1,batch_size = BATCH_SIZE, shuffle = False)\ntrain_dataloader_2 = DataLoader(train_data_2,batch_size = BATCH_SIZE, shuffle = True)\nval_dataloader_2 = DataLoader(val_data_2,batch_size = BATCH_SIZE, shuffle = False)\ntrain_dataloader_3 = DataLoader(train_data_3,batch_size = BATCH_SIZE, shuffle = True)\nval_dataloader_3 = DataLoader(val_data_3,batch_size = BATCH_SIZE, shuffle = False)\ntrain_dataloader_4 = DataLoader(train_data_4,batch_size = BATCH_SIZE, shuffle = True)\nval_dataloader_4 = DataLoader(val_data_4,batch_size = BATCH_SIZE, shuffle = False)","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:10:00.953099Z","iopub.execute_input":"2024-11-18T23:10:00.953393Z","iopub.status.idle":"2024-11-18T23:10:25.084984Z","shell.execute_reply.started":"2024-11-18T23:10:00.953371Z","shell.execute_reply":"2024-11-18T23:10:25.083883Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"optimizer = torch.optim.Adam(model.parameters(), lr = LR)\nbce_b = nn.BCEWithLogitsLoss(pos_weight = torch.tensor([2.0]).to('cuda'))\nbce_e = nn.BCEWithLogitsLoss(pos_weight = torch.tensor([4.0]).to('cuda'))\ncce = nn.CrossEntropyLoss(label_smoothing = 0.05, weight = torch.tensor([1.0, 2.0, 4.0]).to('cuda'))\nscheduler = ReduceLROnPlateau(optimizer, mode='min', patience=5, factor=0.5, verbose=True)","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:10:25.086239Z","iopub.execute_input":"2024-11-18T23:10:25.086588Z","iopub.status.idle":"2024-11-18T23:10:25.094568Z","shell.execute_reply.started":"2024-11-18T23:10:25.086556Z","shell.execute_reply":"2024-11-18T23:10:25.093714Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# initialize metrics objects\ntrain_acc_bowel = MetricsCalculator('binary')\ntrain_acc_extravasation = MetricsCalculator('binary')\ntrain_acc_liver = MetricsCalculator('multi')\ntrain_acc_kidney = MetricsCalculator('multi')\ntrain_acc_spleen = MetricsCalculator('multi')\n\nval_acc_bowel = MetricsCalculator('binary')\nval_acc_extravasation = MetricsCalculator('binary')\nval_acc_liver = MetricsCalculator('multi')\nval_acc_kidney = MetricsCalculator('multi')\nval_acc_spleen = MetricsCalculator('multi')","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:10:25.095557Z","iopub.execute_input":"2024-11-18T23:10:25.095837Z","iopub.status.idle":"2024-11-18T23:10:25.103066Z","shell.execute_reply.started":"2024-11-18T23:10:25.095801Z","shell.execute_reply":"2024-11-18T23:10:25.102265Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"prev_val_best_loss = float('inf')\n\ndataloaders = [(train_dataloader_0, val_dataloader_0),\n               (train_dataloader_1, val_dataloader_1),\n               (train_dataloader_2, val_dataloader_2), \n               (train_dataloader_3, val_dataloader_3),\n               (train_dataloader_4, val_dataloader_4)]\n\nfor epoch in range(NUM_EPOCHS):\n    \n    # training\n    model.train()\n    \n    train_loss = 0.0\n    val_loss = 0.0\n    \n    print(f'Epoch: [{epoch+1}/{NUM_EPOCHS}]')\n    \n    train_dataloader, val_dataloader = dataloaders[epoch%5]\n    \n    print(f'Fold: {epoch%5}')\n    \n    for batch_idx, batch_data in enumerate(tqdm(train_dataloader)):\n        \n        inputs = batch_data['image'].to('cuda')\n        bowel = batch_data['bowel'].to('cuda')\n        extravasation = batch_data['extravasation'].to('cuda')\n        liver = batch_data['liver'].to('cuda')\n        kidney = batch_data['kidney'].to('cuda')\n        spleen = batch_data['spleen'].to('cuda')\n        \n        optimizer.zero_grad()\n        b, e, k, l, s = model(inputs)\n        b_loss = bce_b(b, bowel.float())\n        e_loss = bce_e(e, extravasation.float())\n        l_loss = cce(l, liver)\n        k_loss = cce(k, kidney)\n        s_loss = cce(s, spleen)\n        \n        total_loss = b_loss + e_loss + l_loss + k_loss + s_loss\n        total_loss.backward()\n        \n        optimizer.step()\n        \n        # calculate training metrics\n        train_loss += total_loss.item()\n        train_acc_bowel.update(b, bowel)\n        train_acc_extravasation.update(e, extravasation)\n        train_acc_liver.update(l, liver)\n        train_acc_kidney.update(k, kidney)\n        train_acc_spleen.update(s, spleen)\n    \n    train_loss = train_loss/(batch_idx+1)\n    \n    # validation\n    model.eval()\n    running_loss = 0.0\n    \n    for batch_idx, batch_data in enumerate(tqdm(val_dataloader)):\n                                                \n        inputs = batch_data['image'].to('cuda')\n        bowel = batch_data['bowel'].to('cuda')\n        extravasation = batch_data['extravasation'].to('cuda')\n        liver = batch_data['liver'].to('cuda')\n        kidney = batch_data['kidney'].to('cuda')\n        spleen = batch_data['spleen'].to('cuda')\n\n        \n        b, e, k, l, s = model(inputs)\n        b_loss = bce_b(b, bowel.float())\n        e_loss = bce_e(e, extravasation.float())\n        l_loss = cce(l, liver)\n        k_loss = cce(k, kidney)\n        s_loss = cce(s, spleen)\n        \n        total_loss = b_loss + e_loss + l_loss + k_loss + s_loss\n        \n        # calculate validation metrics\n        val_loss += total_loss.item()\n        val_acc_bowel.update(b, bowel)\n        val_acc_extravasation.update(e, extravasation)\n        val_acc_liver.update(l, liver)\n        val_acc_kidney.update(k, kidney)\n        val_acc_spleen.update(s, spleen)\n    \n    \n    val_loss = val_loss/(batch_idx+1)\n    scheduler.step(val_loss)\n    \n    if val_loss < prev_val_best_loss:\n        prev_val_best_loss = val_loss\n        print(\"Validation Loss improved, Saving Model...\")\n        torch.save(model, f'efficientnet_b0_{val_loss:.3f}.pth')\n    \n    \n    \n    # accuracy and auc data\n    metrics_data = [\n                    [\"Bowel\", \n                        train_acc_bowel.compute_accuracy(),\n                        val_acc_bowel.compute_accuracy(),\n                        train_acc_bowel.compute_auc(),\n                        val_acc_bowel.compute_auc()],\n                    [\"Extravasation\", \n                        train_acc_extravasation.compute_accuracy(),\n                        val_acc_extravasation.compute_accuracy(),\n                        train_acc_extravasation.compute_auc(),\n                        val_acc_extravasation.compute_auc()],\n                    [\"Liver\", \n                        train_acc_liver.compute_accuracy(),\n                        val_acc_liver.compute_accuracy(),\n                        train_acc_liver.compute_auc(),\n                        val_acc_liver.compute_auc()],\n                    [\"Kidney\", \n                        train_acc_kidney.compute_accuracy(),\n                        val_acc_kidney.compute_accuracy(),\n                        train_acc_kidney.compute_auc(),\n                        val_acc_kidney.compute_auc()],\n                    [\"Spleen\", \n                        train_acc_spleen.compute_accuracy(),\n                        val_acc_spleen.compute_accuracy(),\n                        train_acc_spleen.compute_auc(),\n                        val_acc_spleen.compute_auc()]\n                ]\n    \n    # verbose\n    print('')\n    print(tabulate(metrics_data, headers=[\"\", \"Train Acc\", \"Val Acc\", \"Train AUC\", \"Val AUC\"]))\n    \n    print(f'\\nMean Train Loss: {train_loss:.3f}')\n    print(f'Mean Val Loss: {val_loss:.3f}\\n')\n    \n    #reset metrics\n    train_acc_bowel.reset()\n    train_acc_extravasation.reset()\n    train_acc_liver.reset()\n    train_acc_kidney.reset()\n    train_acc_spleen.reset()\n    val_acc_bowel.reset()\n    val_acc_extravasation.reset()\n    val_acc_liver.reset()\n    val_acc_kidney.reset()\n    val_acc_spleen.reset()","metadata":{"execution":{"iopub.status.busy":"2024-11-18T23:10:25.104222Z","iopub.execute_input":"2024-11-18T23:10:25.104835Z","iopub.status.idle":"2024-11-19T04:53:24.727575Z","shell.execute_reply.started":"2024-11-18T23:10:25.104806Z","shell.execute_reply":"2024-11-19T04:53:24.726795Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.model_selection import cross_val_score, StratifiedKFold\nfrom sklearn.metrics import make_scorer, precision_score, recall_score, f1_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\nimport numpy as np\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ở đây sử dụng RandomForest)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Định nghĩa các hàm tính Precision, Recall, F1 và Accuracy\ndef calculate_precision(model, X, y):\n    return precision_score(y, model.predict(X), average='weighted')\n\ndef calculate_recall(model, X, y):\n    return recall_score(y, model.predict(X), average='weighted')\n\ndef calculate_f1(model, X, y):\n    return f1_score(y, model.predict(X), average='weighted')\n\n# Tính toán các chỉ số qua cross-validation\naccuracies = cross_val_score(model, X, y, cv=kf, scoring='accuracy')\nprecisions = cross_val_score(model, X, y, cv=kf, scoring=make_scorer(calculate_precision, greater_is_better=True))\nrecalls = cross_val_score(model, X, y, cv=kf, scoring=make_scorer(calculate_recall, greater_is_better=True))\nf1_scores = cross_val_score(model, X, y, cv=kf, scoring=make_scorer(calculate_f1, greater_is_better=True))\n\n# Tính toán trung bình của các chỉ số\navg_accuracy = np.mean(accuracies)\navg_precision = np.mean(precisions)\navg_recall = np.mean(recalls)\navg_f1 = np.mean(f1_scores)\n\n# In kết quả\nprint(f\"Accuracy trung bình: {avg_accuracy * 100:.2f}%\")\nprint(f\"Precision trung bình: {avg_precision * 100:.2f}%\")\nprint(f\"Recall trung bình: {avg_recall * 100:.2f}%\")\nprint(f\"F1 Score trung bình: {avg_f1 * 100:.2f}%\")\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:24.729401Z","iopub.execute_input":"2024-11-19T04:53:24.729686Z","iopub.status.idle":"2024-11-19T04:53:27.735486Z","shell.execute_reply.started":"2024-11-19T04:53:24.729653Z","shell.execute_reply":"2024-11-19T04:53:27.73467Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.model_selection import cross_val_score, StratifiedKFold, cross_val_predict\nfrom sklearn.metrics import make_scorer, precision_score, recall_score, f1_score, log_loss\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\nimport numpy as np\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ở đây sử dụng RandomForest)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Tính toán các chỉ số qua cross-validation\naccuracies = cross_val_score(model, X, y, cv=kf, scoring='accuracy')\nprecisions = cross_val_score(model, X, y, cv=kf, scoring='precision_weighted')\nrecalls = cross_val_score(model, X, y, cv=kf, scoring='recall_weighted')\nf1_scores = cross_val_score(model, X, y, cv=kf, scoring='f1_weighted')\n\n# Tính toán trung bình của các chỉ số\navg_accuracy = np.mean(accuracies)\navg_precision = np.mean(precisions)\navg_recall = np.mean(recalls)\navg_f1 = np.mean(f1_scores)\n\n# Tính toán Validation Loss (log loss) và Validation Accuracy\nval_losses = []\nval_accuracies = []\n\n# Dùng cross_val_predict để dự đoán lớp cho mỗi fold\nfor train_index, val_index in kf.split(X, y):\n    X_train, X_val = X[train_index], X[val_index]\n    y_train, y_val = y[train_index], y[val_index]\n    \n    model.fit(X_train, y_train)\n    y_pred = model.predict(X_val)\n    \n    # Tính Accuracy và Log Loss cho từng fold\n    val_accuracy = accuracy_score(y_val, y_pred)\n    val_loss = log_loss(y_val, model.predict_proba(X_val))\n    \n    val_accuracies.append(val_accuracy)\n    val_losses.append(val_loss)\n\n# Tính trung bình Validation Accuracy và Validation Loss\navg_val_accuracy = np.mean(val_accuracies)\navg_val_loss = np.mean(val_losses)\n\n# In kết quả\nprint(f\"Accuracy trung bình: {avg_accuracy * 100:.4f}%\")\nprint(f\"Precision trung bình: {avg_precision * 100:.4f}%\")\nprint(f\"Recall trung bình: {avg_recall * 100:.4f}%\")\nprint(f\"F1 Score trung bình: {avg_f1 * 100:.4f}%\")\nprint(f\"Validation Accuracy trung bình: {avg_val_accuracy * 100:.4f}%\")\nprint(f\"Validation Loss trung bình: {avg_val_loss:.4f}\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-19T05:12:09.697474Z","iopub.execute_input":"2024-11-19T05:12:09.697817Z","iopub.status.idle":"2024-11-19T05:12:13.096988Z","shell.execute_reply.started":"2024-11-19T05:12:09.697794Z","shell.execute_reply":"2024-11-19T05:12:13.095978Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.model_selection import cross_val_score, StratifiedKFold, cross_val_predict\nfrom sklearn.metrics import make_scorer, precision_score, recall_score, f1_score, log_loss\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\nimport numpy as np\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ở đây sử dụng RandomForest)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Tính toán các chỉ số qua cross-validation\naccuracies = cross_val_score(model, X, y, cv=kf, scoring='accuracy')\nprecisions = cross_val_score(model, X, y, cv=kf, scoring='precision_weighted')\nrecalls = cross_val_score(model, X, y, cv=kf, scoring='recall_weighted')\nf1_scores = cross_val_score(model, X, y, cv=kf, scoring='f1_weighted')\n\n# Tính toán trung bình của các chỉ số\navg_accuracy = np.mean(accuracies)\navg_precision = np.mean(precisions)\navg_recall = np.mean(recalls)\navg_f1 = np.mean(f1_scores)\n\n# Tính toán Validation Loss (log loss) và Validation Accuracy\nval_losses = []\nval_accuracies = []\n\n# Dùng cross_val_predict để dự đoán lớp cho mỗi fold\nfor train_index, val_index in kf.split(X, y):\n    X_train, X_val = X[train_index], X[val_index]\n    y_train, y_val = y[train_index], y[val_index]\n    \n    model.fit(X_train, y_train)\n    y_pred = model.predict(X_val)\n    \n    # Tính Accuracy và Log Loss cho từng fold\n    val_accuracy = accuracy_score(y_val, y_pred)\n    val_loss = log_loss(y_val, model.predict_proba(X_val))\n    \n    val_accuracies.append(val_accuracy)\n    val_losses.append(val_loss)\n\n# Tính trung bình Validation Accuracy và Validation Loss\navg_val_accuracy = np.mean(val_accuracies)\navg_val_loss = np.mean(val_losses)\n\n# In kết quả\nprint(f\"Accuracy trung bình: {avg_accuracy * 100:.4f}%\")\nprint(f\"Precision trung bình: {avg_precision * 100:.4f}%\")\nprint(f\"Recall trung bình: {avg_recall * 100:.4f}%\")\nprint(f\"F1 Score trung bình: {avg_f1 * 100:.4f}%\")\nprint(f\"Validation Accuracy trung bình: {avg_val_accuracy * 100:.4f}%\")\nprint(f\"Validation Loss trung bình: {avg_val_loss:.4f}\")\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:27.737026Z","iopub.execute_input":"2024-11-19T04:53:27.737397Z","iopub.status.idle":"2024-11-19T04:53:31.153679Z","shell.execute_reply.started":"2024-11-19T04:53:27.737362Z","shell.execute_reply":"2024-11-19T04:53:31.152616Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"pip install matplotlib pillow\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:31.155056Z","iopub.execute_input":"2024-11-19T04:53:31.155427Z","iopub.status.idle":"2024-11-19T04:53:39.972248Z","shell.execute_reply.started":"2024-11-19T04:53:31.155395Z","shell.execute_reply":"2024-11-19T04:53:39.971147Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# Hàm hiển thị hình ảnh với nhãn\ndef show_images(dataloader, num_images=5):\n    images_shown = 0\n    plt.figure(figsize=(15, 10))\n\n    for batch_data in dataloader:\n        images = batch_data['image']\n        labels = {\n            'bowel': batch_data['bowel'],\n            'extravasation': batch_data['extravasation'],\n            'liver': batch_data['liver'],\n            'kidney': batch_data['kidney'],\n            'spleen': batch_data['spleen']\n        }\n        \n        for i in range(images.size(0)):\n            if images_shown >= num_images:\n                plt.show()\n                return\n            \n            img = images[i].permute(1, 2, 0).cpu().numpy()  # Đổi thứ tự kênh ảnh từ (C, H, W) thành (H, W, C) để hiển thị\n            \n            # Hiển thị hình ảnh và các nhãn tương ứng\n            plt.subplot(1, num_images, images_shown + 1)\n            plt.imshow(img, cmap='gray')  # cmap='gray' nếu ảnh là grayscale\n            plt.axis('off')\n            \n            # Lấy các nhãn cho ảnh hiện tại\n            title = \"\\n\".join([f\"{key}: {label[i].item()}\" for key, label in labels.items()])\n            plt.title(title, fontsize=8)\n            \n            images_shown += 1\n\n    plt.show()\n\n\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:39.973718Z","iopub.execute_input":"2024-11-19T04:53:39.973983Z","iopub.status.idle":"2024-11-19T04:53:39.983677Z","shell.execute_reply.started":"2024-11-19T04:53:39.973956Z","shell.execute_reply":"2024-11-19T04:53:39.982845Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Gọi hàm hiển thị một batch từ dataloader\nshow_images(train_dataloader, num_images=5)","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:39.984845Z","iopub.execute_input":"2024-11-19T04:53:39.985099Z","iopub.status.idle":"2024-11-19T04:53:41.009824Z","shell.execute_reply.started":"2024-11-19T04:53:39.985078Z","shell.execute_reply":"2024-11-19T04:53:41.008975Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Gọi hàm hiển thị một batch từ dataloader\nshow_images(train_dataloader, num_images=5)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-19T05:09:34.637949Z","iopub.execute_input":"2024-11-19T05:09:34.638341Z","iopub.status.idle":"2024-11-19T05:09:35.388559Z","shell.execute_reply.started":"2024-11-19T05:09:34.638312Z","shell.execute_reply":"2024-11-19T05:09:35.387621Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Gọi hàm hiển thị một batch từ dataloader\nshow_images(train_dataloader, num_images=5)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-19T05:09:42.964973Z","iopub.execute_input":"2024-11-19T05:09:42.965745Z","iopub.status.idle":"2024-11-19T05:09:43.687948Z","shell.execute_reply.started":"2024-11-19T05:09:42.965713Z","shell.execute_reply":"2024-11-19T05:09:43.68726Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Gọi hàm hiển thị một batch từ dataloader\nshow_images(train_dataloader, num_images=5)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-19T05:09:50.326409Z","iopub.execute_input":"2024-11-19T05:09:50.326853Z","iopub.status.idle":"2024-11-19T05:09:51.056461Z","shell.execute_reply.started":"2024-11-19T05:09:50.326818Z","shell.execute_reply":"2024-11-19T05:09:51.055581Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"pip install seaborn matplotlib\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:41.010947Z","iopub.execute_input":"2024-11-19T04:53:41.011258Z","iopub.status.idle":"2024-11-19T04:53:48.982236Z","shell.execute_reply.started":"2024-11-19T04:53:41.011232Z","shell.execute_reply":"2024-11-19T04:53:48.981085Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nimport pandas as pd\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ví dụ RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả accuracy của từng mẫu trong mỗi fold\nfold_accuracies = {f'Fold {i}': [] for i in range(kf.get_n_splits())}\n\n# Thực hiện cross-validation\nfor fold, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính accuracy cho từng mẫu trong validation set\n    y_pred = model.predict(X_val)\n    \n    # Tính độ chính xác cho từng mẫu (so sánh dự đoán với nhãn thực tế)\n    fold_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu độ chính xác vào danh sách tương ứng với từng fold\n    fold_accuracies[f'Fold {fold}'].extend([fold_accuracy] * len(y_val))  # Thêm độ chính xác cho mỗi mẫu\n\n# Kiểm tra dữ liệu fold_accuracies\nprint(fold_accuracies)\n\n# Chuyển dữ liệu từ dictionary thành DataFrame\naccuracies_df = pd.DataFrame(fold_accuracies)\n\n# Hiển thị boxplot cho từng fold\nplt.figure(figsize=(8, 6))\nsns.boxplot(data=accuracies_df)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Boxplot of Accuracy for Each Fold')\nplt.xlabel('Folds')\nplt.ylabel('Accuracy')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:48.984088Z","iopub.execute_input":"2024-11-19T04:53:48.984793Z","iopub.status.idle":"2024-11-19T04:53:50.104984Z","shell.execute_reply.started":"2024-11-19T04:53:48.984751Z","shell.execute_reply":"2024-11-19T04:53:50.104189Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu Iris\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold với n_splits=5\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả độ chính xác của mỗi fold\nfold_results = []\n\n# Thực hiện cross-validation\nfor fold, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính độ chính xác cho validation set\n    y_pred = model.predict(X_val)\n    fold_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu kết quả độ chính xác của fold\n    fold_results.append(fold_accuracy)\n\n# Kiểm tra dữ liệu fold_results\nprint(fold_results)  # In ra độ chính xác của từng fold\n\n# Vẽ Boxplot cho các độ chính xác qua các fold (0 đến 4)\nplt.figure(figsize=(10, 6))\n\n# Chuyển đổi fold_results thành danh sách các độ chính xác cho từng fold (kết quả là một danh sách các giá trị độ chính xác cho từng fold)\nsns.boxplot(data=[fold_results])  # Dữ liệu fold_results là một danh sách các giá trị độ chính xác của 5 fold\n\n# Thêm tiêu đề và nhãn\nplt.title('Boxplot of Accuracy Across Different Folds')\nplt.xlabel('Fold')\nplt.ylabel('Accuracy')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:50.106107Z","iopub.execute_input":"2024-11-19T04:53:50.106401Z","iopub.status.idle":"2024-11-19T04:53:50.919978Z","shell.execute_reply.started":"2024-11-19T04:53:50.106369Z","shell.execute_reply":"2024-11-19T04:53:50.919102Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu Iris\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold với n_splits=5\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả độ chính xác của mỗi fold\nfold_results = {i: [] for i in range(5)}  # Tạo dictionary để lưu độ chính xác của từng fold\n\n# Thực hiện cross-validation\nfor fold, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính độ chính xác cho validation set\n    y_pred = model.predict(X_val)\n    fold_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu độ chính xác của fold vào dictionary\n    fold_results[fold].append(fold_accuracy)\n\n# Kiểm tra kết quả fold_results\nprint(fold_results)\n\n# Vẽ Boxplot cho các độ chính xác của từng fold\nplt.figure(figsize=(10, 6))\n\n# Dữ liệu fold_results sẽ là một danh sách các độ chính xác của từng fold (kf 0, kf 1, kf 2, kf 3, kf 4)\nsns.boxplot(data=[fold_results[0], fold_results[1], fold_results[2], fold_results[3], fold_results[4]])\n\n# Thêm tiêu đề và nhãn\nplt.title('Boxplot of Accuracy Across Different Folds')\nplt.xlabel('Fold')\nplt.ylabel('Validation Accuracy')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:50.920995Z","iopub.execute_input":"2024-11-19T04:53:50.921356Z","iopub.status.idle":"2024-11-19T04:53:51.777989Z","shell.execute_reply.started":"2024-11-19T04:53:50.921323Z","shell.execute_reply":"2024-11-19T04:53:51.77701Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nimport pandas as pd\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ví dụ RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả accuracy của mỗi fold\nfold_results = []\n\n# Thực hiện cross-validation\nfor fold, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính accuracy cho validation set\n    y_pred = model.predict(X_val)\n    fold_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu kết quả độ chính xác của fold\n    fold_results.append(fold_accuracy)\n\n# Kiểm tra dữ liệu của fold_results\nprint(fold_results)\n\n# Tính trung bình độ chính xác của tất cả các fold\nmean_accuracy = np.mean(fold_results)\n\n# Vẽ Boxplot từ các kết quả fold_results\nplt.figure(figsize=(8, 6))\n\n# Thêm một chiều dữ liệu để tạo nhóm cho boxplot\nsns.boxplot(data=[fold_results])  # Đây sẽ tạo ra boxplot cho tập hợp độ chính xác của tất cả các folds\n\n# Thêm dòng trung bình độ chính xác vào boxplot\nplt.axhline(mean_accuracy, color='red', linestyle='--', label=f'Mean Accuracy: {mean_accuracy:.2f}')\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Boxplot of Accuracy Across Different Folds')\nplt.xlabel('Folds')\nplt.ylabel('Accuracy')\n\n# Hiển thị chú thích cho dòng trung bình\nplt.legend()\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:51.77909Z","iopub.execute_input":"2024-11-19T04:53:51.77947Z","iopub.status.idle":"2024-11-19T04:53:52.702172Z","shell.execute_reply.started":"2024-11-19T04:53:51.779437Z","shell.execute_reply":"2024-11-19T04:53:52.701243Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ví dụ RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả accuracy của mỗi fold\ntrain_accuracies = []  # Lưu độ chính xác huấn luyện\nval_accuracies = []    # Lưu độ chính xác validation\n\n# Số lượng epoch (folds)\nepochs = 5\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các epoch\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính accuracy cho tập huấn luyện và tập validation\n    y_train_pred = model.predict(X_train)\n    y_val_pred = model.predict(X_val)\n    \n    # Tính độ chính xác cho tập huấn luyện và validation\n    train_accuracy = accuracy_score(y_train, y_train_pred)\n    val_accuracy = accuracy_score(y_val, y_val_pred)\n    \n    # Lưu kết quả vào danh sách\n    train_accuracies.append(train_accuracy)\n    val_accuracies.append(val_accuracy)\n\n# Vẽ đồ thị accuracy qua các epoch\nepochs_range = np.arange(1, epochs + 1)\n\nplt.figure(figsize=(8, 6))\n\n# Vẽ độ chính xác huấn luyện\nplt.plot(epochs_range, train_accuracies, label='Train Accuracy', marker='o', linestyle='-', color='blue')\n\n# Vẽ độ chính xác validation\nplt.plot(epochs_range, val_accuracies, label='Validation Accuracy', marker='o', linestyle='--', color='green')\n\n# Thêm tiêu đề và nhãn\nplt.title('Accuracy vs Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('Accuracy')\nplt.xticks(epochs_range)  # Đảm bảo trục x có đủ các nhãn cho mỗi epoch\nplt.legend()\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:52.703354Z","iopub.execute_input":"2024-11-19T04:53:52.703677Z","iopub.status.idle":"2024-11-19T04:53:53.681727Z","shell.execute_reply.started":"2024-11-19T04:53:52.703645Z","shell.execute_reply":"2024-11-19T04:53:53.680873Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ví dụ RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả accuracy của mỗi fold\ntrain_accuracies = []  # Lưu độ chính xác huấn luyện\nval_accuracies = []    # Lưu độ chính xác validation\n\n# Số lượng fold (cross-validation)\nn_folds = 5\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các fold\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính accuracy cho tập huấn luyện và tập validation\n    y_train_pred = model.predict(X_train)\n    y_val_pred = model.predict(X_val)\n    \n    # Tính độ chính xác cho tập huấn luyện và validation\n    train_accuracy = accuracy_score(y_train, y_train_pred)\n    val_accuracy = accuracy_score(y_val, y_val_pred)\n    \n    # Lưu kết quả vào danh sách\n    train_accuracies.append(train_accuracy)\n    val_accuracies.append(val_accuracy)\n\n# Vẽ đồ thị accuracy qua các fold\nfolds_range = np.arange(1, n_folds + 1)  # Tạo mảng cho các fold\n\nplt.figure(figsize=(8, 6))\n\n# Vẽ độ chính xác huấn luyện\nplt.plot(folds_range, train_accuracies, label='Train Accuracy', marker='o', linestyle='-', color='blue')\n\n# Vẽ độ chính xác validation\nplt.plot(folds_range, val_accuracies, label='Validation Accuracy', marker='o', linestyle='--', color='green')\n\n# Thêm tiêu đề và nhãn\nplt.title('Accuracy vs Fold')\nplt.xlabel('Fold')\nplt.ylabel('Accuracy')\n\n# Điều chỉnh trục x chỉ hiển thị mỗi fold (1, 2, 3, ...)\nplt.xticks(folds_range)  # Hiển thị các mốc mỗi fold\n\nplt.legend()\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:53.688839Z","iopub.execute_input":"2024-11-19T04:53:53.689074Z","iopub.status.idle":"2024-11-19T04:53:54.598478Z","shell.execute_reply.started":"2024-11-19T04:53:53.689053Z","shell.execute_reply":"2024-11-19T04:53:54.597652Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.datasets import load_iris\nfrom sklearn.model_selection import train_test_split\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.utils import to_categorical\n\n# Tải dữ liệu Iris\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Chuyển đổi nhãn thành one-hot encoding\ny = to_categorical(y)\n\n# Chia dữ liệu thành tập huấn luyện và tập kiểm tra\nX_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)\n\n# Xây dựng mô hình mạng nơ-ron đơn giản\nmodel = Sequential()\nmodel.add(Dense(64, input_dim=4, activation='relu'))\nmodel.add(Dense(3, activation='softmax'))\n\n# Biên dịch mô hình\nmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n# Lưu trữ kết quả accuracy theo các epoch\nhistory = model.fit(X_train, y_train, epochs=200, batch_size=16, validation_data=(X_val, y_val), verbose=0)\n\n# Lấy độ chính xác theo từng epoch\ntrain_accuracies = history.history['accuracy']\nval_accuracies = history.history['val_accuracy']\n\n# Vẽ đồ thị độ chính xác qua các epoch\nepochs_range = np.arange(1, 201)  # Đặt số epoch từ 1 đến 200\n\nplt.figure(figsize=(8, 6))\n\n# Vẽ độ chính xác huấn luyện (đường thẳng)\nplt.plot(epochs_range, train_accuracies, label='Train Accuracy', linestyle='-', color='blue')\n\n# Vẽ độ chính xác validation (đường thẳng)\nplt.plot(epochs_range, val_accuracies, label='Validation Accuracy', linestyle='-', color='ORANGE')\n\n# Thêm tiêu đề và nhãn\nplt.title('Accuracy vs Epoch')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\n\n# Điều chỉnh trục x chỉ hiển thị mỗi 25 epoch\nplt.xticks(np.arange(1, 201, step=25))  # Hiển thị mốc mỗi 25 epoch\n\nplt.legend()\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:53:54.599899Z","iopub.execute_input":"2024-11-19T04:53:54.600533Z","iopub.status.idle":"2024-11-19T04:54:13.691316Z","shell.execute_reply.started":"2024-11-19T04:53:54.600494Z","shell.execute_reply":"2024-11-19T04:54:13.690518Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.metrics import log_loss\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (ví dụ RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả accuracy và loss của mỗi fold\ntrain_losses = []  # Lưu giá trị loss huấn luyện\nval_losses = []    # Lưu giá trị loss validation\n\n# Số lượng epoch (folds)\nepochs = 5\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các epoch\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán và tính accuracy cho tập huấn luyện và tập validation\n    y_train_pred = model.predict(X_train)\n    y_val_pred = model.predict(X_val)\n    \n    # Tính loss cho tập huấn luyện và validation\n    train_loss = log_loss(y_train, model.predict_proba(X_train))  # Sử dụng log_loss cho huấn luyện\n    val_loss = log_loss(y_val, model.predict_proba(X_val))  # Sử dụng log_loss cho validation\n    \n    # Lưu kết quả vào danh sách\n    train_losses.append(train_loss)\n    val_losses.append(val_loss)\n\n# Vẽ đồ thị loss qua các epoch\nepochs_range = np.arange(1, epochs + 1)\n\nplt.figure(figsize=(8, 6))\n\n# Vẽ train loss\nplt.plot(epochs_range, train_losses, label='Train Loss', marker='o', linestyle='-', color='blue')\n\n# Vẽ validation loss\nplt.plot(epochs_range, val_losses, label='Validation Loss', marker='o', linestyle='--', color='green')\n\n# Thêm tiêu đề và nhãn\nplt.title('Loss vs Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('Loss')\n\n# Đảm bảo trục x có đủ các nhãn cho mỗi epoch (1, 2, 3, ..., 5)\nplt.xticks(epochs_range)\n\n# Thêm chú thích cho đồ thị\nplt.legend()\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:54:13.692718Z","iopub.execute_input":"2024-11-19T04:54:13.693252Z","iopub.status.idle":"2024-11-19T04:54:14.699557Z","shell.execute_reply.started":"2024-11-19T04:54:13.693217Z","shell.execute_reply":"2024-11-19T04:54:14.698649Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score, confusion_matrix\nfrom sklearn.datasets import load_iris\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Lưu kết quả confusion matrix cho mỗi fold\nconfusion_matrices = []\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các epoch\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán cho tập validation\n    y_val_pred = model.predict(X_val)\n    \n    # Tính ma trận nhầm lẫn cho tập validation\n    cm = confusion_matrix(y_val, y_val_pred)\n    confusion_matrices.append(cm)\n\n# Tính trung bình ma trận nhầm lẫn trên tất cả các fold\navg_confusion_matrix = np.mean(confusion_matrices, axis=0)\n\n# Vẽ ma trận nhầm lẫn\nplt.figure(figsize=(8, 6))\nsns.heatmap(avg_confusion_matrix, annot=True, fmt='g', cmap='Blues', xticklabels=data.target_names, yticklabels=data.target_names)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Average Confusion Matrix (Over All Folds)')\nplt.xlabel('Predicted Labels')\nplt.ylabel('True Labels')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:54:14.700559Z","iopub.execute_input":"2024-11-19T04:54:14.70082Z","iopub.status.idle":"2024-11-19T04:54:15.648031Z","shell.execute_reply.started":"2024-11-19T04:54:14.700798Z","shell.execute_reply":"2024-11-19T04:54:15.64711Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn.datasets import load_digits  # Dữ liệu MNIST hoặc dataset tương tự\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Digits dataset, có 10 lớp từ 0 đến 9)\nfrom sklearn.datasets import load_digits\ndata = load_digits()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Lưu kết quả confusion matrix cho mỗi fold\nconfusion_matrices = []\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các epoch\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán cho tập validation\n    y_val_pred = model.predict(X_val)\n    \n    # Tính ma trận nhầm lẫn cho tập validation\n    cm = confusion_matrix(y_val, y_val_pred)\n    confusion_matrices.append(cm)\n\n# Tính trung bình ma trận nhầm lẫn trên tất cả các fold\navg_confusion_matrix = np.mean(confusion_matrices, axis=0)\n\n# Vẽ ma trận nhầm lẫn\nplt.figure(figsize=(8, 6))\nsns.heatmap(avg_confusion_matrix, annot=True, fmt='g', cmap='Blues', xticklabels=data.target_names, yticklabels=data.target_names)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Average Confusion Matrix (Over All Folds)')\nplt.xlabel('Predicted Labels')\nplt.ylabel('True Labels')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:54:15.649617Z","iopub.execute_input":"2024-11-19T04:54:15.649954Z","iopub.status.idle":"2024-11-19T04:54:17.803325Z","shell.execute_reply.started":"2024-11-19T04:54:15.649922Z","shell.execute_reply":"2024-11-19T04:54:17.802404Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\nfrom sklearn.datasets import load_digits\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Digits dataset, có 10 lớp từ 0 đến 9)\ndata = load_digits()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả của từng metrics\ntrain_accuracies = []\nval_accuracies = []\ntrain_precisions = []\nval_precisions = []\ntrain_recalls = []\nval_recalls = []\ntrain_f1_scores = []\nval_f1_scores = []\n\n# Số lượng epoch (ở đây mỗi epoch là một lần huấn luyện trong vòng 5 fold)\nepochs = 200\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các epoch\nfor epoch in range(epochs):\n    # Lưu kết quả cho mỗi epoch\n    fold_train_accuracies = []\n    fold_val_accuracies = []\n    fold_train_precisions = []\n    fold_val_precisions = []\n    fold_train_recalls = []\n    fold_val_recalls = []\n    fold_train_f1_scores = []\n    fold_val_f1_scores = []\n    \n    for train_idx, val_idx in kf.split(X, y):\n        X_train, X_val = X[train_idx], X[val_idx]\n        y_train, y_val = y[train_idx], y[val_idx]\n        \n        # Huấn luyện mô hình\n        model.fit(X_train, y_train)\n        \n        # Dự đoán cho tập huấn luyện và tập validation\n        y_train_pred = model.predict(X_train)\n        y_val_pred = model.predict(X_val)\n        \n        # Tính các metrics cho tập huấn luyện và tập validation\n        train_accuracy = accuracy_score(y_train, y_train_pred)\n        val_accuracy = accuracy_score(y_val, y_val_pred)\n        \n        train_precision = precision_score(y_train, y_train_pred, average='weighted')\n        val_precision = precision_score(y_val, y_val_pred, average='weighted')\n        \n        train_recall = recall_score(y_train, y_train_pred, average='weighted')\n        val_recall = recall_score(y_val, y_val_pred, average='weighted')\n        \n        train_f1 = f1_score(y_train, y_train_pred, average='weighted')\n        val_f1 = f1_score(y_val, y_val_pred, average='weighted')\n        \n        # Lưu kết quả vào các danh sách của mỗi fold\n        fold_train_accuracies.append(train_accuracy)\n        fold_val_accuracies.append(val_accuracy)\n        \n        fold_train_precisions.append(train_precision)\n        fold_val_precisions.append(val_precision)\n        \n        fold_train_recalls.append(train_recall)\n        fold_val_recalls.append(val_recall)\n        \n        fold_train_f1_scores.append(train_f1)\n        fold_val_f1_scores.append(val_f1)\n    \n    # Sau khi hoàn thành một epoch (mỗi vòng lặp của cross-validation), tính toán và lưu kết quả\n    train_accuracies.append(np.mean(fold_train_accuracies))\n    val_accuracies.append(np.mean(fold_val_accuracies))\n    train_precisions.append(np.mean(fold_train_precisions))\n    val_precisions.append(np.mean(fold_val_precisions))\n    train_recalls.append(np.mean(fold_train_recalls))\n    val_recalls.append(np.mean(fold_val_recalls))\n    train_f1_scores.append(np.mean(fold_train_f1_scores))\n    val_f1_scores.append(np.mean(fold_val_f1_scores))\n\n# Tạo các biểu đồ cho từng metrics\nepochs_range = np.arange(1, epochs + 1)\n\n# Vẽ biểu đồ cho accuracy\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_accuracies, label='Train Accuracy', marker='o', color='blue')\nplt.plot(epochs_range, val_accuracies, label='Validation Accuracy', marker='o', color='green')\nplt.title('Accuracy vs Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('Accuracy')\nplt.xticks(epochs_range)\nplt.legend()\nplt.show()\n\n# Vẽ biểu đồ cho precision\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_precisions, label='Train Precision', marker='o', color='blue')\nplt.plot(epochs_range, val_precisions, label='Validation Precision', marker='o', color='green')\nplt.title('Precision vs Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('Precision')\nplt.xticks(epochs_range)\nplt.legend()\nplt.show()\n\n# Vẽ biểu đồ cho recall\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_recalls, label='Train Recall', marker='o', color='blue')\nplt.plot(epochs_range, val_recalls, label='Validation Recall', marker='o', color='green')\nplt.title('Recall vs Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('Recall')\nplt.xticks(epochs_range)\nplt.legend()\nplt.show()\n\n# Vẽ biểu đồ cho F1 Score\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_f1_scores, label='Train F1 Score', marker='o', color='blue')\nplt.plot(epochs_range, val_f1_scores, label='Validation F1 Score', marker='o', color='green')\nplt.title('F1 Score vs Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('F1 Score')\nplt.xticks(epochs_range)\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T04:54:17.804953Z","iopub.execute_input":"2024-11-19T04:54:17.805318Z","iopub.status.idle":"2024-11-19T05:00:50.126782Z","shell.execute_reply.started":"2024-11-19T04:54:17.805283Z","shell.execute_reply":"2024-11-19T05:00:50.125916Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\nfrom sklearn.datasets import load_digits\nfrom sklearn.ensemble import RandomForestClassifier\n\n# Tải dữ liệu ví dụ (Digits dataset, có 10 lớp từ 0 đến 9)\ndata = load_digits()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold với n_splits=5\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả của từng metrics\ntrain_accuracies = []\nval_accuracies = []\ntrain_precisions = []\nval_precisions = []\ntrain_recalls = []\nval_recalls = []\ntrain_f1_scores = []\nval_f1_scores = []\n\n# Số lượng fold (epochs ở đây là số lượng folds = 5)\nepochs = 5\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các fold\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y)):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán cho tập huấn luyện và tập validation\n    y_train_pred = model.predict(X_train)\n    y_val_pred = model.predict(X_val)\n    \n    # Tính các metrics cho tập huấn luyện và tập validation\n    train_accuracy = accuracy_score(y_train, y_train_pred)\n    val_accuracy = accuracy_score(y_val, y_val_pred)\n    \n    train_precision = precision_score(y_train, y_train_pred, average='weighted')\n    val_precision = precision_score(y_val, y_val_pred, average='weighted')\n    \n    train_recall = recall_score(y_train, y_train_pred, average='weighted')\n    val_recall = recall_score(y_val, y_val_pred, average='weighted')\n    \n    train_f1 = f1_score(y_train, y_train_pred, average='weighted')\n    val_f1 = f1_score(y_val, y_val_pred, average='weighted')\n    \n    # Lưu kết quả vào các danh sách\n    train_accuracies.append(train_accuracy)\n    val_accuracies.append(val_accuracy)\n    \n    train_precisions.append(train_precision)\n    val_precisions.append(val_precision)\n    \n    train_recalls.append(train_recall)\n    val_recalls.append(val_recall)\n    \n    train_f1_scores.append(train_f1)\n    val_f1_scores.append(val_f1)\n\n# Tạo các biểu đồ cho từng metrics\nepochs_range = np.arange(1, epochs + 1)  # Sử dụng 5 epochs (folds)\n\n# Vẽ biểu đồ cho accuracy\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_accuracies, label='Train Accuracy', marker='o', color='blue')\nplt.plot(epochs_range, val_accuracies, label='Validation Accuracy', marker='o', color='green')\nplt.title('Accuracy vs Epochs (Fold 1-5)')\nplt.xlabel('Fold')\nplt.ylabel('Accuracy')\nplt.xticks(epochs_range)  # Hiển thị mốc mỗi fold (từ 1 đến 5)\nplt.legend()\nplt.show()\n\n# Vẽ biểu đồ cho precision\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_precisions, label='Train Precision', marker='o', color='blue')\nplt.plot(epochs_range, val_precisions, label='Validation Precision', marker='o', color='green')\nplt.title('Precision vs Epochs (Fold 1-5)')\nplt.xlabel('Fold')\nplt.ylabel('Precision')\nplt.xticks(epochs_range)  # Hiển thị mốc mỗi fold (từ 1 đến 5)\nplt.legend()\nplt.show()\n\n# Vẽ biểu đồ cho recall\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_recalls, label='Train Recall', marker='o', color='blue')\nplt.plot(epochs_range, val_recalls, label='Validation Recall', marker='o', color='green')\nplt.title('Recall vs Epochs (Fold 1-5)')\nplt.xlabel('Fold')\nplt.ylabel('Recall')\nplt.xticks(epochs_range)  # Hiển thị mốc mỗi fold (từ 1 đến 5)\nplt.legend()\nplt.show()\n\n# Vẽ biểu đồ cho F1 Score\nplt.figure(figsize=(10, 6))\nplt.plot(epochs_range, train_f1_scores, label='Train F1 Score', marker='o', color='blue')\nplt.plot(epochs_range, val_f1_scores, label='Validation F1 Score', marker='o', color='green')\nplt.title('F1 Score vs Epochs (Fold 1-5)')\nplt.xlabel('Fold')\nplt.ylabel('F1 Score')\nplt.xticks(epochs_range)  # Hiển thị mốc mỗi fold (từ 1 đến 5)\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:00:50.127981Z","iopub.execute_input":"2024-11-19T05:00:50.128255Z","iopub.status.idle":"2024-11-19T05:00:53.162649Z","shell.execute_reply.started":"2024-11-19T05:00:50.128232Z","shell.execute_reply":"2024-11-19T05:00:53.161739Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nfrom sklearn.metrics import confusion_matrix\nimport numpy as np\n\n# Giả sử y_true và y_pred là danh sách nhãn thật và nhãn dự đoán\n# Ví dụ dữ liệu giả cho nhãn thật và nhãn dự đoán\ny_true = [\n    'bowel_healthy', 'bowel_injury', 'bowel_healthy', 'bowel_injury', 'extravasation_healthy',\n    'extravasation_injury', 'kidney_healthy', 'kidney_low', 'kidney_high', 'liver_healthy',\n    'liver_low', 'kidney_low', 'liver_healthy', 'bowel_injury', 'liver_low'\n]  # Các nhãn thật\n\ny_pred = [\n    'bowel_healthy', 'bowel_injury', 'bowel_healthy', 'bowel_injury', 'extravasation_healthy',\n    'extravasation_injury', 'kidney_healthy', 'kidney_low', 'kidney_high', 'liver_healthy',\n    'liver_low', 'kidney_low', 'liver_healthy', 'bowel_injury', 'liver_healthy'\n]  # Các nhãn dự đoán (giả sử giống với y_true)\n\n# Danh sách các lớp (labels)\nlabels = [\n    'bowel_healthy', 'bowel_injury', 'extravasation_healthy', 'extravasation_injury',\n    'kidney_healthy', 'kidney_low', 'kidney_high', 'liver_healthy', 'liver_low'\n]\n\n# Tính toán ma trận nhầm lẫn\ncm = confusion_matrix(y_true, y_pred, labels=labels)\n\n# Vẽ ma trận nhầm lẫn\nplt.figure(figsize=(10, 8))\nsns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels, cbar=False)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Confusion Matrix')\nplt.xlabel('Predicted Labels')\nplt.ylabel('True Labels')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:00:53.16396Z","iopub.execute_input":"2024-11-19T05:00:53.164239Z","iopub.status.idle":"2024-11-19T05:00:53.579388Z","shell.execute_reply.started":"2024-11-19T05:00:53.164216Z","shell.execute_reply":"2024-11-19T05:00:53.578526Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.datasets import load_iris\nfrom sklearn.metrics import accuracy_score\n\n# Giả sử bạn đã huấn luyện một mô hình và có các giá trị loss (ví dụ, train_loss, val_loss)\ntrain_losses = []\nval_losses = []\n\n# Dữ liệu giả lập (ví dụ: Iris dataset)\ndata = load_iris()\nX = data.data\ny = data.target\n\n# Đổi dữ liệu thành torch tensors\nX = torch.tensor(X, dtype=torch.float32)\ny = torch.tensor(y, dtype=torch.long)\n\n# Khởi tạo mô hình, loss function và optimizer (ví dụ sử dụng một mô hình đơn giản)\nmodel = nn.Sequential(\n    nn.Linear(X.shape[1], 50),\n    nn.ReLU(),\n    nn.Linear(50, len(set(y.numpy())))\n)\n\nloss_fn = nn.CrossEntropyLoss()\noptimizer = optim.SGD(model.parameters(), lr=0.01)\n\n# Khởi tạo StratifiedKFold\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Thực hiện cross-validation\nfor epoch in range(5):  # Giả sử 5 epoch\n    for train_idx, val_idx in kf.split(X.numpy(), y.numpy()):\n        # Chia dữ liệu thành tập huấn luyện và tập validation\n        X_train, X_val = X[train_idx], X[val_idx]\n        y_train, y_val = y[train_idx], y[val_idx]\n        \n        # Huấn luyện mô hình\n        model.train()\n        optimizer.zero_grad()\n        output = model(X_train)\n        loss = loss_fn(output, y_train)\n        \n        # Cập nhật trọng số\n        loss.backward()\n        optimizer.step()\n        \n        # Lưu train loss\n        train_losses.append(loss.item())\n        \n        # Validation loss\n        model.eval()\n        with torch.no_grad():\n            val_output = model(X_val)\n            val_loss = loss_fn(val_output, y_val)\n            val_losses.append(val_loss.item())\n\n# Vẽ đồ thị\nepochs_range = np.arange(1, len(train_losses) + 1)\n\nplt.figure(figsize=(10, 6))\n\n# Vẽ train loss\nplt.plot(epochs_range, train_losses, label='Train Loss', marker='o', linestyle='-', color='blue')\n\n# Vẽ validation loss\nplt.plot(epochs_range, val_losses, label='Validation Loss', marker='o', linestyle='--', color='green')\n\n# Thêm tiêu đề và nhãn\nplt.title('Train Loss vs Validation Loss Across Epochs')\nplt.xlabel('Epochs')\nplt.ylabel('Loss')\nplt.xticks(epochs_range)  # Đảm bảo trục x có đủ các nhãn cho mỗi epoch\nplt.legend()\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:00:53.580835Z","iopub.execute_input":"2024-11-19T05:00:53.581379Z","iopub.status.idle":"2024-11-19T05:00:53.957733Z","shell.execute_reply.started":"2024-11-19T05:00:53.581343Z","shell.execute_reply":"2024-11-19T05:00:53.956912Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\nfrom sklearn.datasets import load_digits\nfrom sklearn.ensemble import RandomForestClassifier\nimport seaborn as sns\n\n# Tải dữ liệu ví dụ (Digits dataset, có 10 lớp từ 0 đến 9)\ndata = load_digits()\nX = data.data\ny = data.target\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả của từng metrics qua các epoch\ntrain_accuracies = []\nval_accuracies = []\ntrain_precisions = []\nval_precisions = []\ntrain_recalls = []\nval_recalls = []\ntrain_f1_scores = []\nval_f1_scores = []\n\n# Số lượng epoch\nepochs = 200\n\n# Thực hiện cross-validation và huấn luyện mô hình qua các epoch\nfor epoch in range(epochs):\n    fold_train_accuracies = []\n    fold_val_accuracies = []\n    fold_train_precisions = []\n    fold_val_precisions = []\n    fold_train_recalls = []\n    fold_val_recalls = []\n    fold_train_f1_scores = []\n    fold_val_f1_scores = []\n    \n    # Chạy qua các fold\n    for train_idx, val_idx in kf.split(X, y):\n        X_train, X_val = X[train_idx], X[val_idx]\n        y_train, y_val = y[train_idx], y[val_idx]\n        \n        # Huấn luyện mô hình\n        model.fit(X_train, y_train)\n        \n        # Dự đoán cho tập huấn luyện và tập validation\n        y_train_pred = model.predict(X_train)\n        y_val_pred = model.predict(X_val)\n        \n        # Tính các metrics cho tập huấn luyện và tập validation\n        train_accuracy = accuracy_score(y_train, y_train_pred)\n        val_accuracy = accuracy_score(y_val, y_val_pred)\n        \n        train_precision = precision_score(y_train, y_train_pred, average='weighted')\n        val_precision = precision_score(y_val, y_val_pred, average='weighted')\n        \n        train_recall = recall_score(y_train, y_train_pred, average='weighted')\n        val_recall = recall_score(y_val, y_val_pred, average='weighted')\n        \n        train_f1 = f1_score(y_train, y_train_pred, average='weighted')\n        val_f1 = f1_score(y_val, y_val_pred, average='weighted')\n        \n        # Lưu kết quả vào các danh sách của mỗi fold\n        fold_train_accuracies.append(train_accuracy)\n        fold_val_accuracies.append(val_accuracy)\n        \n        fold_train_precisions.append(train_precision)\n        fold_val_precisions.append(val_precision)\n        \n        fold_train_recalls.append(train_recall)\n        fold_val_recalls.append(val_recall)\n        \n        fold_train_f1_scores.append(train_f1)\n        fold_val_f1_scores.append(val_f1)\n    \n    # Lưu kết quả cho mỗi epoch (average của các fold)\n    train_accuracies.append(np.mean(fold_train_accuracies))\n    val_accuracies.append(np.mean(fold_val_accuracies))\n    train_precisions.append(np.mean(fold_train_precisions))\n    val_precisions.append(np.mean(fold_val_precisions))\n    train_recalls.append(np.mean(fold_train_recalls))\n    val_recalls.append(np.mean(fold_val_recalls))\n    train_f1_scores.append(np.mean(fold_train_f1_scores))\n    val_f1_scores.append(np.mean(fold_val_f1_scores))\n\n# Vẽ boxplot cho các metrics qua các epoch\nmetrics = ['Accuracy', 'Precision', 'Recall', 'F1 Score']\nvalues = [train_accuracies, val_accuracies, train_precisions, val_precisions, \n          train_recalls, val_recalls, train_f1_scores, val_f1_scores]\n\n# Chia thành các nhóm để vẽ boxplot\nfig, axes = plt.subplots(2, 2, figsize=(12, 10))\n\n# Boxplot cho Accuracy\nsns.boxplot(data=[train_accuracies, val_accuracies], ax=axes[0, 0])\naxes[0, 0].set_title('Accuracy Distribution')\naxes[0, 0].set_xticklabels(['Train Accuracy', 'Validation Accuracy'])\naxes[0, 0].set_ylabel('Accuracy')\n\n# Boxplot cho Precision\nsns.boxplot(data=[train_precisions, val_precisions], ax=axes[0, 1])\naxes[0, 1].set_title('Precision Distribution')\naxes[0, 1].set_xticklabels(['Train Precision', 'Validation Precision'])\naxes[0, 1].set_ylabel('Precision')\n\n# Boxplot cho Recall\nsns.boxplot(data=[train_recalls, val_recalls], ax=axes[1, 0])\naxes[1, 0].set_title('Recall Distribution')\naxes[1, 0].set_xticklabels(['Train Recall', 'Validation Recall'])\naxes[1, 0].set_ylabel('Recall')\n\n# Boxplot cho F1 Score\nsns.boxplot(data=[train_f1_scores, val_f1_scores], ax=axes[1, 1])\naxes[1, 1].set_title('F1 Score Distribution')\naxes[1, 1].set_xticklabels(['Train F1 Score', 'Validation F1 Score'])\naxes[1, 1].set_ylabel('F1 Score')\n\n# Hiển thị đồ thị\nplt.tight_layout()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:00:53.959282Z","iopub.execute_input":"2024-11-19T05:00:53.959609Z","iopub.status.idle":"2024-11-19T05:07:18.071578Z","shell.execute_reply.started":"2024-11-19T05:00:53.959579Z","shell.execute_reply":"2024-11-19T05:07:18.070678Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.datasets import load_iris  # Thay thế với dữ liệu thực tế của bạn\n\n# Giả sử bạn có dữ liệu với các lớp: Bowel, Extravasation, Liver, Kidney, Spleen\n# Ở đây, tôi sử dụng Iris dataset làm ví dụ. Bạn cần thay thế bằng dữ liệu thực tế của bạn.\n\n# Tải dữ liệu (thay thế với dữ liệu thực tế của bạn)\ndata = load_iris()\nX = data.data\ny = data.target  # Trong ví dụ này, các lớp là 0, 1, 2 (bạn sẽ thay bằng các lớp tương ứng)\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả độ chính xác cho từng lớp\naccuracies_bowel = []\naccuracies_extravasation = []\naccuracies_liver = []\naccuracies_kidney = []\naccuracies_spleen = []\n\n# Số lượng lớp (5 lớp trong trường hợp của bạn)\nclasses = ['Bowel', 'Extravasation', 'Liver', 'Kidney', 'Spleen']\n\n# Thực hiện cross-validation và tính độ chính xác cho mỗi lớp\nfor train_idx, val_idx in kf.split(X, y):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán cho tập validation\n    y_pred = model.predict(X_val)\n    \n    # Tính độ chính xác chung cho từng fold\n    fold_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu độ chính xác vào các danh sách cho các lớp\n    accuracies_bowel.append(fold_accuracy)\n    accuracies_extravasation.append(fold_accuracy)\n    accuracies_liver.append(fold_accuracy)\n    accuracies_kidney.append(fold_accuracy)\n    accuracies_spleen.append(fold_accuracy)\n\n# Vẽ boxplot cho từng lớp\nplt.figure(figsize=(10, 6))\n\n# Dữ liệu cần vẽ boxplot\ndata_for_boxplot = [\n    accuracies_bowel,\n    accuracies_extravasation,\n    accuracies_liver,\n    accuracies_kidney,\n    accuracies_spleen\n]\n\n# Vẽ boxplot\nsns.boxplot(data=data_for_boxplot)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Boxplot of Accuracy for Each Class')\nplt.xticks(ticks=np.arange(len(classes)), labels=classes)\nplt.ylabel('Accuracy')\nplt.xlabel('Classes')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:07:18.072781Z","iopub.execute_input":"2024-11-19T05:07:18.073065Z","iopub.status.idle":"2024-11-19T05:07:19.009817Z","shell.execute_reply.started":"2024-11-19T05:07:18.073041Z","shell.execute_reply":"2024-11-19T05:07:19.008933Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.datasets import load_iris  # Thay thế với dữ liệu thực tế của bạn\n\n# Giả sử bạn có dữ liệu với các lớp: Bowel, Extravasation, Liver, Kidney, Spleen\n# Ở đây, tôi sử dụng Iris dataset làm ví dụ. Bạn cần thay thế bằng dữ liệu thực tế của bạn.\n\n# Tải dữ liệu (thay thế với dữ liệu thực tế của bạn)\ndata = load_iris()\nX = data.data\ny = data.target  # Trong ví dụ này, các lớp là 0, 1, 2 (bạn sẽ thay bằng các lớp tương ứng)\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả độ chính xác cho từng lớp\naccuracies_bowel = []\naccuracies_extravasation = []\naccuracies_liver = []\naccuracies_kidney = []\naccuracies_spleen = []\n\n# Số lượng lớp (5 lớp trong trường hợp của bạn)\nclasses = ['Bowel', 'Extravasation', 'Liver', 'Kidney', 'Spleen']\n\n# Thực hiện cross-validation và tính độ chính xác cho mỗi lớp\nfor train_idx, val_idx in kf.split(X, y):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán cho tập validation\n    y_pred = model.predict(X_val)\n    \n    # Tính độ chính xác cho tập validation (val_accuracy)\n    val_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu độ chính xác vào các danh sách cho các lớp\n    accuracies_bowel.append(val_accuracy)\n    accuracies_extravasation.append(val_accuracy)\n    accuracies_liver.append(val_accuracy)\n    accuracies_kidney.append(val_accuracy)\n    accuracies_spleen.append(val_accuracy)\n\n# Vẽ boxplot cho từng lớp\nplt.figure(figsize=(10, 6))\n\n# Dữ liệu cần vẽ boxplot\ndata_for_boxplot = [\n    accuracies_bowel,\n    accuracies_extravasation,\n    accuracies_liver,\n    accuracies_kidney,\n    accuracies_spleen\n]\n\n# Vẽ boxplot\nsns.boxplot(data=data_for_boxplot)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Boxplot of Validation Accuracy for Each Class')\nplt.xticks(ticks=np.arange(len(classes)), labels=classes)\nplt.ylabel('Validation Accuracy')\nplt.xlabel('Classes')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:07:19.011322Z","iopub.execute_input":"2024-11-19T05:07:19.011567Z","iopub.status.idle":"2024-11-19T05:07:19.935841Z","shell.execute_reply.started":"2024-11-19T05:07:19.011546Z","shell.execute_reply":"2024-11-19T05:07:19.935045Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.datasets import load_iris  # Thay thế với dữ liệu thực tế của bạn\n\n# Giả sử bạn có dữ liệu với các lớp: Bowel, Extravasation, Liver, Kidney, Spleen\n# Ở đây, tôi sử dụng Iris dataset làm ví dụ. Bạn cần thay thế bằng dữ liệu thực tế của bạn.\n\n# Tải dữ liệu (thay thế với dữ liệu thực tế của bạn)\ndata = load_iris()\nX = data.data\ny = data.target  # Trong ví dụ này, các lớp là 0, 1, 2 (bạn sẽ thay bằng các lớp tương ứng)\n\n# Khởi tạo mô hình (RandomForestClassifier)\nmodel = RandomForestClassifier()\n\n# Khởi tạo StratifiedKFold (chọn k=5 để phân chia dữ liệu)\nkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\n# Danh sách lưu kết quả độ chính xác cho từng lớp (dùng tên lớp là \"epoch\")\nepoch_bowel = []\nepoch_extravasation = []\nepoch_liver = []\nepoch_kidney = []\nepoch_spleen = []\n\n# Số lượng lớp (5 lớp trong trường hợp của bạn)\nclasses = ['Bowel', 'Extravasation', 'Liver', 'Kidney', 'Spleen']\n\n# Thực hiện cross-validation và tính độ chính xác cho mỗi lớp\nfor epoch, (train_idx, val_idx) in enumerate(kf.split(X, y), start=1):\n    X_train, X_val = X[train_idx], X[val_idx]\n    y_train, y_val = y[train_idx], y[val_idx]\n    \n    # Huấn luyện mô hình\n    model.fit(X_train, y_train)\n    \n    # Dự đoán cho tập validation\n    y_pred = model.predict(X_val)\n    \n    # Tính độ chính xác cho tập validation (val_accuracy)\n    val_accuracy = accuracy_score(y_val, y_pred)\n    \n    # Lưu độ chính xác vào các danh sách cho các lớp (tên là epoch)\n    epoch_bowel.append(val_accuracy)\n    epoch_extravasation.append(val_accuracy)\n    epoch_liver.append(val_accuracy)\n    epoch_kidney.append(val_accuracy)\n    epoch_spleen.append(val_accuracy)\n\n# Vẽ boxplot cho từng lớp (tương ứng với các epoch)\nplt.figure(figsize=(10, 6))\n\n# Dữ liệu cần vẽ boxplot\ndata_for_boxplot = [\n    epoch_bowel,\n    epoch_extravasation,\n    epoch_liver,\n    epoch_kidney,\n    epoch_spleen\n]\n\n# Vẽ boxplot\nsns.boxplot(data=data_for_boxplot)\n\n# Thêm tiêu đề và nhãn trục\nplt.title('Boxplot of Accuracy (Epoch) for Each Class')\nplt.xticks(ticks=np.arange(len(classes)), labels=classes)\nplt.ylabel('Accuracy (Epoch)')\nplt.xlabel('Classes')\n\n# Hiển thị đồ thị\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-11-19T05:07:19.937451Z","iopub.execute_input":"2024-11-19T05:07:19.937789Z","iopub.status.idle":"2024-11-19T05:07:20.85989Z","shell.execute_reply.started":"2024-11-19T05:07:19.937757Z","shell.execute_reply":"2024-11-19T05:07:20.859002Z"},"trusted":true},"outputs":[],"execution_count":null}]}