Delete mri_autoencoder.ipynb

mri_autoencoder.ipynb

@@ -1,685 +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": "markdown",
-   "metadata": {},
-   "source": [
-    "### Pure U-Net"
-   ]
-  },
-  {
-   "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",
-    "def calculate_psnr(output, target, max_pixel=1.0):\n",
-    "    # Ensure the values are in the correct range\n",
-    "    mse = F.mse_loss(output, target)\n",
-    "    psnr = 20 * torch.log10(max_pixel / torch.sqrt(mse))\n",
-    "    return psnr.item()\n",
-    "\n",
-    "def calculate_loss_and_psnr(model, dataloader, criterion):\n",
-    "    model.eval()\n",
-    "    total_loss = 0\n",
-    "    total_psnr = 0\n",
-    "    num_batches = len(dataloader)\n",
-    "    \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",
-    "            \n",
-    "            # Calculate MSE loss\n",
-    "            loss = criterion(outputs, targets)\n",
-    "            total_loss += loss.item()\n",
-    "            \n",
-    "            # Calculate PSNR\n",
-    "            psnr = calculate_psnr(outputs, targets)\n",
-    "            total_psnr += psnr\n",
-    "    \n",
-    "    avg_loss = total_loss / num_batches\n",
-    "    avg_psnr = total_psnr / num_batches\n",
-    "    \n",
-    "    return avg_loss, avg_psnr\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, avg_val_psnr = calculate_loss_and_psnr(model, val_dataloader, criterion)\n",
-    "        \n",
-    "        print(f\"Epoch [{epoch+1}/{epochs}] - Train Loss: {avg_train_loss:.4f}, Validation Loss: {avg_val_loss:.4f}, Validation PSNR: {avg_val_psnr:.4f}\")\n",
-    "\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)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Reconstructor and Denoiser U-Net"
-   ]
-  },
-  {
-   "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",
-    "def calculate_psnr(output, target, max_pixel=1.0):\n",
-    "    # Ensure the values are in the correct range\n",
-    "    mse = F.mse_loss(output, target)\n",
-    "    psnr = 20 * torch.log10(max_pixel / torch.sqrt(mse))\n",
-    "    return psnr.item()\n",
-    "\n",
-    "def calculate_loss_and_psnr(model, dataloader, criterion):\n",
-    "    model.eval()\n",
-    "    total_loss = 0\n",
-    "    total_psnr = 0\n",
-    "    num_batches = len(dataloader)\n",
-    "    \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",
-    "            \n",
-    "            # Calculate MSE loss\n",
-    "            loss = criterion(outputs, targets)\n",
-    "            total_loss += loss.item()\n",
-    "            \n",
-    "            # Calculate PSNR\n",
-    "            psnr = calculate_psnr(outputs, targets)\n",
-    "            total_psnr += psnr\n",
-    "    \n",
-    "    avg_loss = total_loss / num_batches\n",
-    "    avg_psnr = total_psnr / num_batches\n",
-    "    \n",
-    "    return avg_loss, avg_psnr\n",
-    "\n",
-    "class Reconstructor(nn.Module):\n",
-    "    def __init__(self, in_channels=1, out_channels=1):\n",
-    "        super().__init__()\n",
-    "        # Same UNet architecture for reconstruction\n",
-    "        self.unet = UNet(in_channels=in_channels, out_channels=out_channels)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        return self.unet(x)\n",
-    "\n",
-    "\n",
-    "class Denoiser(nn.Module):\n",
-    "    def __init__(self, in_channels=1, out_channels=1):\n",
-    "        super().__init__()\n",
-    "        # Same UNet architecture for denoising\n",
-    "        self.unet = UNet(in_channels=in_channels, out_channels=out_channels)\n",
-    "    \n",
-    "    def forward(self, x):\n",
-    "        return self.unet(x)\n",
-    "\n",
-    "\n",
-    "def train_reconstructor_and_denoiser(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",
-    "    # Initialize both models\n",
-    "    reconstructor = Reconstructor().to(device)\n",
-    "    denoiser = Denoiser().to(device)\n",
-    "    \n",
-    "    # Loss functions for both models\n",
-    "    reconstructor_criterion = nn.MSELoss()\n",
-    "    denoiser_criterion = nn.MSELoss()\n",
-    "    \n",
-    "    # Optimizers for both models\n",
-    "    reconstructor_optimizer = torch.optim.Adam(reconstructor.parameters(), lr=0.0001)\n",
-    "    denoiser_optimizer = torch.optim.Adam(denoiser.parameters(), lr=0.0001)\n",
-    "    \n",
-    "    # Best validation loss initialization\n",
-    "    best_reconstructor_val_loss = float('inf')\n",
-    "    best_denoiser_val_loss = float('inf')\n",
-    "    best_reconstructor_model_path = 'best_reconstructor_model.pth'\n",
-    "    best_denoiser_model_path = 'best_denoiser_model.pth'\n",
-    "\n",
-    "    # Training loop with tqdm\n",
-    "    for epoch in range(epochs):\n",
-    "        reconstructor.train()\n",
-    "        denoiser.train()\n",
-    "        \n",
-    "        reconstructor_total_loss = 0\n",
-    "        denoiser_total_loss = 0\n",
-    "        \n",
-    "        reconstructor_optimizer.zero_grad()\n",
-    "        denoiser_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",
-    "                # Training Reconstructor\n",
-    "                reconstructor_outputs = reconstructor(images)\n",
-    "                reconstructor_loss = reconstructor_criterion(reconstructor_outputs, targets)\n",
-    "                reconstructor_loss.backward()\n",
-    "\n",
-    "                # Gradient accumulation for reconstructor\n",
-    "                if (i + 1) % grad_accumulation_steps == 0 or (i + 1) == len(tepoch):\n",
-    "                    reconstructor_optimizer.step()\n",
-    "                    reconstructor_optimizer.zero_grad()\n",
-    "\n",
-    "                reconstructor_total_loss += reconstructor_loss.item()\n",
-    "\n",
-    "                # Training Denoiser (using output from Reconstructor as noisy input)\n",
-    "                noisy_images = reconstructor_outputs\n",
-    "                denoiser_outputs = denoiser(noisy_images)\n",
-    "                denoiser_loss = denoiser_criterion(denoiser_outputs, targets)\n",
-    "                denoiser_loss.backward()\n",
-    "\n",
-    "                # Gradient accumulation for denoiser\n",
-    "                if (i + 1) % grad_accumulation_steps == 0 or (i + 1) == len(tepoch):\n",
-    "                    denoiser_optimizer.step()\n",
-    "                    denoiser_optimizer.zero_grad()\n",
-    "\n",
-    "                denoiser_total_loss += denoiser_loss.item()\n",
-    "\n",
-    "                # Update the tqdm progress bar with current loss\n",
-    "                tepoch.set_postfix(\n",
-    "                    reconstructor_loss=reconstructor_total_loss / ((i + 1) * batch_size),\n",
-    "                    denoiser_loss=denoiser_total_loss / ((i + 1) * batch_size)\n",
-    "                )\n",
-    "        \n",
-    "        # Calculate validation loss for both models\n",
-    "        avg_reconstructor_train_loss = reconstructor_total_loss / len(train_dataloader)\n",
-    "        avg_denoiser_train_loss = denoiser_total_loss / len(train_dataloader)\n",
-    "        \n",
-    "        avg_reconstructor_val_loss, _ = calculate_loss_and_psnr(reconstructor, val_dataloader, reconstructor_criterion)\n",
-    "        avg_denoiser_val_loss, _ = calculate_loss_and_psnr(denoiser, val_dataloader, denoiser_criterion)\n",
-    "        \n",
-    "        print(f\"Epoch [{epoch+1}/{epochs}] - \"\n",
-    "              f\"Reconstructor Train Loss: {avg_reconstructor_train_loss:.4f}, \"\n",
-    "              f\"Denoiser Train Loss: {avg_denoiser_train_loss:.4f}, \"\n",
-    "              f\"Reconstructor Val Loss: {avg_reconstructor_val_loss:.4f}, \"\n",
-    "              f\"Denoiser Val Loss: {avg_denoiser_val_loss:.4f}\")\n",
-    "        \n",
-    "        # Save models if validation loss is improved\n",
-    "        if avg_reconstructor_val_loss < best_reconstructor_val_loss:\n",
-    "            best_reconstructor_val_loss = avg_reconstructor_val_loss\n",
-    "            torch.save(reconstructor.state_dict(), best_reconstructor_model_path)\n",
-    "            print(f\"Reconstructor model saved with improved validation loss: {avg_reconstructor_val_loss:.4f}\")\n",
-    "        \n",
-    "        if avg_denoiser_val_loss < best_denoiser_val_loss:\n",
-    "            best_denoiser_val_loss = avg_denoiser_val_loss\n",
-    "            torch.save(denoiser.state_dict(), best_denoiser_model_path)\n",
-    "            print(f\"Denoiser model saved with improved validation loss: {avg_denoiser_val_loss:.4f}\")\n",
-    "    \n",
-    "    return reconstructor, denoiser\n",
-    "\n",
-    "\n",
-    "# Example usage with train and validation directories\n",
-    "reconstructor_model, denoiser_model = train_reconstructor_and_denoiser(\n",
-    "    r\"D:\\PN_Split\\train\", r\"D:\\PN_Split\\val\", epochs=50, batch_size=4, grad_accumulation_steps=8\n",
-    ")"
-   ]
-  }
- ],
- "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
-}