Delete mri_autoencoder.ipynb

mri_autoencoder.ipynb

@@ -1,393 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import shutil\n",
-    "\n",
-    "def deepcopy_and_rename_dicom(src_folder, dest_folder):\n",
-    "    # Ensure the destination folder exists\n",
-    "    if not os.path.exists(dest_folder):\n",
-    "        os.makedirs(dest_folder)\n",
-    "\n",
-    "    # Variable to keep track of the sequential number for the renamed files\n",
-    "    file_counter = 1\n",
-    "\n",
-    "    # Walk through the source folder and its subdirectories\n",
-    "    for root, dirs, files in os.walk(src_folder):\n",
-    "        for dicom_file in files:\n",
-    "            # Check if the file has a .dcm extension\n",
-    "            if dicom_file.lower().endswith('.dcm'):\n",
-    "                # Get the full path of the DICOM file\n",
-    "                src_file_path = os.path.join(root, dicom_file)\n",
-    "                \n",
-    "                # Generate the new file path for the destination folder\n",
-    "                dest_file_path = os.path.join(dest_folder, f\"{file_counter}.dcm\")\n",
-    "                \n",
-    "                # Copy the file to the destination folder and rename it\n",
-    "                shutil.copy(src_file_path, dest_file_path)\n",
-    "                print(f\"Copied and renamed {dicom_file} to {file_counter}.dcm\")\n",
-    "                \n",
-    "                # Increment the counter for the next file\n",
-    "                file_counter += 1\n",
-    "\n",
-    "# Example usage:\n",
-    "src_folder = r\"D:\\Pancreatic Neuroendocrine\"  # Replace with your source main folder path\n",
-    "dest_folder = r\"D:\\PN_New\"       # Replace with your destination folder path\n",
-    "deepcopy_and_rename_dicom(src_folder, dest_folder)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import shutil\n",
-    "import random\n",
-    "\n",
-    "def split_and_transfer_files(src_folder, dest_folder, split_factor):\n",
-    "    \"\"\"\n",
-    "    Splits the files in src_folder and moves them into train and val subfolders in dest_folder\n",
-    "    based on the provided split_factor.\n",
-    "    \n",
-    "    :param src_folder: The source folder containing the files to split.\n",
-    "    :param dest_folder: The destination folder where the train and val subfolders will be created.\n",
-    "    :param split_factor: The ratio of files to go into the train subfolder (e.g., 0.8 for 80% train, 20% val).\n",
-    "    \"\"\"\n",
-    "    # Ensure the destination folder and subfolders exist\n",
-    "    train_folder = os.path.join(dest_folder, 'train')\n",
-    "    val_folder = os.path.join(dest_folder, 'val')\n",
-    "    \n",
-    "    if not os.path.exists(train_folder):\n",
-    "        os.makedirs(train_folder)\n",
-    "    \n",
-    "    if not os.path.exists(val_folder):\n",
-    "        os.makedirs(val_folder)\n",
-    "\n",
-    "    # Get all DICOM files in the source folder\n",
-    "    dicom_files = [f for f in os.listdir(src_folder) if f.lower().endswith('.dcm')]\n",
-    "    \n",
-    "    # Shuffle the files for randomness\n",
-    "    random.shuffle(dicom_files)\n",
-    "\n",
-    "    # Calculate the number of files for the train and validation sets\n",
-    "    split_index = int(len(dicom_files) * split_factor)\n",
-    "    \n",
-    "    # Split the files into train and val sets\n",
-    "    train_files = dicom_files[:split_index]\n",
-    "    val_files = dicom_files[split_index:]\n",
-    "    \n",
-    "    # Move the files to the respective folders\n",
-    "    for file in train_files:\n",
-    "        src_file = os.path.join(src_folder, file)\n",
-    "        dest_file = os.path.join(train_folder, file)\n",
-    "        shutil.move(src_file, dest_file)\n",
-    "        print(f\"Moved {file} to train folder\")\n",
-    "    \n",
-    "    for file in val_files:\n",
-    "        src_file = os.path.join(src_folder, file)\n",
-    "        dest_file = os.path.join(val_folder, file)\n",
-    "        shutil.move(src_file, dest_file)\n",
-    "        print(f\"Moved {file} to val folder\")\n",
-    "\n",
-    "# Example usage:\n",
-    "src_folder = r\"D:\\PN_New\"  # Replace with your source folder path\n",
-    "dest_folder = r\"D:\\PN_Split\"  # Replace with your destination folder path\n",
-    "split_factor = 0.9  # 80% of files will go to 'train', 20% will go to 'val'\n",
-    "\n",
-    "split_and_transfer_files(src_folder, dest_folder, split_factor)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "import pydicom\n",
-    "import numpy as np\n",
-    "from torch.utils.data import Dataset, DataLoader\n",
-    "import os\n",
-    "\n",
-    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-    "\n",
-    "class MedicalImageDataset(Dataset):\n",
-    "    def __init__(self, dicom_dir):\n",
-    "        self.dicom_files = [os.path.join(dicom_dir, f) for f in os.listdir(dicom_dir) if f.endswith('.dcm')]\n",
-    "    \n",
-    "    def __len__(self):\n",
-    "        return len(self.dicom_files)\n",
-    "    \n",
-    "    def __getitem__(self, idx):\n",
-    "        # Read DICOM file and normalize\n",
-    "        dcm = pydicom.dcmread(self.dicom_files[idx])\n",
-    "        image = dcm.pixel_array.astype(float)\n",
-    "        image = (image - image.min()) / (image.max() - image.min())\n",
-    "        \n",
-    "        # Convert to tensor\n",
-    "        image_tensor = torch.from_numpy(image).float().unsqueeze(0)\n",
-    "        return image_tensor, image_tensor\n",
-    "\n",
-    "class UNetBlock(nn.Module):\n",
-    "    def __init__(self, in_channels, out_channels):\n",
-    "        super().__init__()\n",
-    "        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1)\n",
-    "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
-    "        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1)\n",
-    "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        x = F.relu(self.bn1(self.conv1(x)))\n",
-    "        x = F.relu(self.bn2(self.conv2(x)))\n",
-    "        return x\n",
-    "\n",
-    "class UNet(nn.Module):\n",
-    "    def __init__(self, in_channels=1, out_channels=1):\n",
-    "        super().__init__()\n",
-    "        # Encoder\n",
-    "        self.enc1 = UNetBlock(in_channels, 64)\n",
-    "        self.enc2 = UNetBlock(64, 128)\n",
-    "        self.enc3 = UNetBlock(128, 256)\n",
-    "        \n",
-    "        # Decoder\n",
-    "        self.dec3 = UNetBlock(256 + 128, 128)  # Adjust for concatenation with skip connection\n",
-    "        self.dec2 = UNetBlock(128 + 64, 64)    # Adjust for concatenation with skip connection\n",
-    "        self.dec1 = UNetBlock(64, out_channels)\n",
-    "        \n",
-    "        # Pooling and upsampling\n",
-    "        self.pool = nn.MaxPool2d(2, 2)\n",
-    "        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        # Encoder path\n",
-    "        e1 = self.enc1(x)\n",
-    "        e2 = self.enc2(self.pool(e1))\n",
-    "        e3 = self.enc3(self.pool(e2))\n",
-    "        \n",
-    "        # Decoder path with skip connections\n",
-    "        d3 = self.upsample(e3)\n",
-    "        d3 = torch.cat([d3, e2], dim=1)  # Concatenate along channels\n",
-    "        d3 = self.dec3(d3)\n",
-    "        \n",
-    "        d2 = self.upsample(d3)\n",
-    "        d2 = torch.cat([d2, e1], dim=1)  # Concatenate along channels\n",
-    "        d2 = self.dec2(d2)\n",
-    "        \n",
-    "        d1 = self.dec1(d2)\n",
-    "        \n",
-    "        return d1\n",
-    "\n",
-    "def train_unet(dicom_dir, epochs=50, batch_size=4):\n",
-    "    # Dataset and DataLoader\n",
-    "    dataset = MedicalImageDataset(dicom_dir)\n",
-    "    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
-    "    \n",
-    "    # Model, Loss, Optimizer\n",
-    "    model = UNet().to(device)\n",
-    "    criterion = nn.MSELoss()\n",
-    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
-    "    \n",
-    "    # Training loop\n",
-    "    for epoch in range(epochs):\n",
-    "        total_loss = 0\n",
-    "        for images, targets in dataloader:\n",
-    "            images, targets = images.to(device), targets.to(device)\n",
-    "            optimizer.zero_grad()\n",
-    "            outputs = model(images)\n",
-    "            loss = criterion(outputs, targets)\n",
-    "            loss.backward()\n",
-    "            optimizer.step()\n",
-    "            total_loss += loss.item()\n",
-    "        \n",
-    "        print(f'Epoch [{epoch+1}/{epochs}], Loss: {total_loss/len(dataloader):.4f}')\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "# Example usage\n",
-    "model = train_unet(r\"D:\\PN_New\", epochs=50, batch_size=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
-    "import pydicom\n",
-    "import numpy as np\n",
-    "from torch.utils.data import Dataset, DataLoader\n",
-    "import os\n",
-    "from torch.utils.checkpoint import checkpoint\n",
-    "from tqdm import tqdm  # Import tqdm for progress bar\n",
-    "\n",
-    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-    "\n",
-    "class MedicalImageDataset(Dataset):\n",
-    "    def __init__(self, dicom_dir):\n",
-    "        self.dicom_files = [os.path.join(dicom_dir, f) for f in os.listdir(dicom_dir) if f.endswith('.dcm')]\n",
-    "    \n",
-    "    def __len__(self):\n",
-    "        return len(self.dicom_files)\n",
-    "    \n",
-    "    def __getitem__(self, idx):\n",
-    "        # Read DICOM file and normalize\n",
-    "        dcm = pydicom.dcmread(self.dicom_files[idx])\n",
-    "        image = dcm.pixel_array.astype(float)\n",
-    "        image = (image - image.min()) / (image.max() - image.min())\n",
-    "        \n",
-    "        # Convert to tensor\n",
-    "        image_tensor = torch.from_numpy(image).float().unsqueeze(0)\n",
-    "        return image_tensor, image_tensor\n",
-    "\n",
-    "class UNetBlock(nn.Module):\n",
-    "    def __init__(self, in_channels, out_channels):\n",
-    "        super().__init__()\n",
-    "        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, padding=1)\n",
-    "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
-    "        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, padding=1)\n",
-    "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        x = F.relu(self.bn1(self.conv1(x)))\n",
-    "        x = F.relu(self.bn2(self.conv2(x)))\n",
-    "        return x\n",
-    "\n",
-    "class UNet(nn.Module):\n",
-    "    def __init__(self, in_channels=1, out_channels=1):\n",
-    "        super().__init__()\n",
-    "        # Encoder\n",
-    "        self.enc1 = UNetBlock(in_channels, 64)\n",
-    "        self.enc2 = UNetBlock(64, 128)\n",
-    "        self.enc3 = UNetBlock(128, 256)\n",
-    "        \n",
-    "        # Decoder\n",
-    "        self.dec3 = UNetBlock(256 + 128, 128)  # Adjust for concatenation with skip connection\n",
-    "        self.dec2 = UNetBlock(128 + 64, 64)    # Adjust for concatenation with skip connection\n",
-    "        self.dec1 = UNetBlock(64, out_channels)\n",
-    "        \n",
-    "        # Pooling and upsampling\n",
-    "        self.pool = nn.MaxPool2d(2, 2)\n",
-    "        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        # Encoder path\n",
-    "        e1 = checkpoint(self.enc1, x)\n",
-    "        e2 = checkpoint(self.enc2, self.pool(e1))\n",
-    "        e3 = checkpoint(self.enc3, self.pool(e2))\n",
-    "        \n",
-    "        # Decoder path with skip connections\n",
-    "        d3 = self.upsample(e3)\n",
-    "        d3 = torch.cat([d3, e2], dim=1)  # Concatenate along channels\n",
-    "        d3 = checkpoint(self.dec3, d3)\n",
-    "        \n",
-    "        d2 = self.upsample(d3)\n",
-    "        d2 = torch.cat([d2, e1], dim=1)  # Concatenate along channels\n",
-    "        d2 = checkpoint(self.dec2, d2)\n",
-    "        \n",
-    "        d1 = self.dec1(d2)  # No checkpointing for final output layer\n",
-    "        \n",
-    "        return d1\n",
-    "\n",
-    "def calculate_loss(model, dataloader, criterion):\n",
-    "    model.eval()\n",
-    "    total_loss = 0\n",
-    "    with torch.no_grad():\n",
-    "        for images, targets in dataloader:\n",
-    "            images, targets = images.to(device), targets.to(device)\n",
-    "            outputs = model(images)\n",
-    "            loss = criterion(outputs, targets)\n",
-    "            total_loss += loss.item()\n",
-    "    return total_loss / len(dataloader)\n",
-    "\n",
-    "best_val_loss = float('inf')\n",
-    "best_model_path = 'best_model.pth'\n",
-    "\n",
-    "def train_unet(dicom_dir, val_dicom_dir, epochs=50, batch_size=4, grad_accumulation_steps=2):\n",
-    "    # Dataset and DataLoader\n",
-    "    dataset = MedicalImageDataset(dicom_dir)\n",
-    "    train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n",
-    "    val_dataset = MedicalImageDataset(val_dicom_dir)\n",
-    "    val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
-    "    \n",
-    "    # Model, Loss, Optimizer\n",
-    "    model = UNet().to(device)\n",
-    "    criterion = nn.MSELoss()\n",
-    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
-    "    \n",
-    "    # Training loop with tqdm\n",
-    "    for epoch in range(epochs):\n",
-    "        model.train()\n",
-    "        total_loss = 0\n",
-    "        optimizer.zero_grad()\n",
-    "        \n",
-    "        with tqdm(train_dataloader, unit=\"batch\", desc=f\"Epoch {epoch+1}/{epochs}\") as tepoch:\n",
-    "            for i, (images, targets) in enumerate(tepoch):\n",
-    "                images, targets = images.to(device), targets.to(device)\n",
-    "                \n",
-    "                # Forward pass\n",
-    "                outputs = model(images)\n",
-    "                loss = criterion(outputs, targets)\n",
-    "                loss.backward()\n",
-    "                \n",
-    "                # Gradient accumulation\n",
-    "                if (i + 1) % grad_accumulation_steps == 0 or (i + 1) == len(tepoch):\n",
-    "                    optimizer.step()\n",
-    "                    optimizer.zero_grad()\n",
-    "                \n",
-    "                total_loss += loss.item()\n",
-    "                \n",
-    "                # Update the tqdm progress bar with the current loss\n",
-    "                tepoch.set_postfix(loss=total_loss / ((i + 1) * batch_size))\n",
-    "        \n",
-    "        avg_train_loss = total_loss / len(train_dataloader)\n",
-    "        avg_val_loss = calculate_loss(model, val_dataloader, criterion)\n",
-    "        \n",
-    "        print(f\"Epoch [{epoch+1}/{epochs}] - Train Loss: {avg_train_loss:.4f}, Validation Loss: {avg_val_loss:.4f}\")\n",
-    "\n",
-    "        # Save model if validation loss is improved\n",
-    "        if avg_val_loss < best_val_loss:\n",
-    "            best_val_loss = avg_val_loss\n",
-    "            torch.save(model.state_dict(), best_model_path)\n",
-    "            print(f\"Model saved with improved validation loss: {avg_val_loss:.4f}\")\n",
-    "    \n",
-    "    return model\n",
-    "\n",
-    "# Example usage with train and validation directories\n",
-    "model = train_unet(r\"D:\\PN_Split\\train\", r\"D:\\PN_Split\\val\", epochs=50, batch_size=4, grad_accumulation_steps=8)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "tf",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}