Upload mri_autoencoder.ipynb with huggingface_hub

mri_autoencoder.ipynb

@@ -261,7 +261,7 @@
     "                    dcm = pydicom.dcmread(full_path)\n",
     "                    \n",
     "                    # Check image dimensions\n",
-    "                    if dcm.pixel_array.shape[0] < min_size or dcm.pixel_array.shape[1] < min_size:\n",
+    "                    if dcm.pixel_array.shape[0] < min_size or dcm.pixel_array.shape[1] < min_size or dcm.pixel_array.shape[0] > min_size or dcm.pixel_array.shape[1] > min_size:\n",
     "                        files_to_delete.append(full_path)\n",
     "                        filtered_images += 1\n",
     "                    \n",
@@ -279,7 +279,7 @@
     "        print(f\"Images deleted: {filtered_images}\\n\")\n",
     "\n",
     "# Usage\n",
-    "input_dirs = [r\"D:\\TCIA_Split\\train\", r\"D:\\TCIA_Split\\val\"]\n",
+    "input_dirs = [\"./TCIA_Split/train\", \"./TCIA_Split/val\"]\n",
     "filter_dicom_images(input_dirs)"
    ]
   },
@@ -928,7 +928,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1347,9 +1347,9 @@
     "# Example usage\n",
     "if __name__ == \"__main__\":\n",
     "    # Paths to models and test image\n",
-    "    RECONSTRUCTOR_MODEL_PATH = r\"D:/VSCODE/PreSense/small_reconstructor.pth\"  # Path to your saved Reconstructor model\n",
-    "    DENOISER_MODEL_PATH = r\"D:/VSCODE/PreSense/small_denoiser.pth\"  # Path to your saved Denoiser model\n",
-    "    TEST_DICOM_PATH = r\"D:/VSCODE/PreSense/test2.dcm\"  # Replace with actual path to test DICOM    \n",
+    "    RECONSTRUCTOR_MODEL_PATH = \"./small_reconstructor.pth\"  # Path to your saved Reconstructor model\n",
+    "    DENOISER_MODEL_PATH = \"./small_denoiser.pth\"  # Path to your saved Denoiser model\n",
+    "    TEST_DICOM_PATH = \"./test.dcm\"  # Replace with actual path to test DICOM    \n",
     "    # Run inference\n",
     "    inference_single_image(RECONSTRUCTOR_MODEL_PATH, DENOISER_MODEL_PATH, TEST_DICOM_PATH)"
    ]
@@ -1644,7 +1644,150 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Larger Reconstructor and Denoiser U-Net (largeRD)"
+    "### mediumRD Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import pydicom\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "\n",
+    "# Import the models from the previous script\n",
+    "# Assuming they are defined or imported correctly\n",
+    "\n",
+    "def load_dicom_image(dicom_path):\n",
+    "    \"\"\"\n",
+    "    Load and normalize a DICOM image\n",
+    "    \n",
+    "    Args:\n",
+    "        dicom_path (str): Path to the DICOM file\n",
+    "    \n",
+    "    Returns:\n",
+    "        torch.Tensor: Normalized image tensor\n",
+    "    \"\"\"\n",
+    "    # Read DICOM file\n",
+    "    dcm = pydicom.dcmread(dicom_path)\n",
+    "    image = dcm.pixel_array.astype(float)\n",
+    "    \n",
+    "    # Normalize image\n",
+    "    image = (image - image.min()) / (image.max() - image.min())\n",
+    "    \n",
+    "    # Convert to tensor\n",
+    "    image_tensor = torch.from_numpy(image).float().unsqueeze(0).unsqueeze(0)  # Add batch and channel dimensions\n",
+    "    return image_tensor\n",
+    "\n",
+    "def calculate_psnr(output, target, max_pixel=1.0):\n",
+    "    \"\"\"\n",
+    "    Calculate Peak Signal-to-Noise Ratio (PSNR)\n",
+    "    \n",
+    "    Args:\n",
+    "        output (torch.Tensor): Reconstructed image\n",
+    "        target (torch.Tensor): Original image\n",
+    "        max_pixel (float): Maximum pixel value\n",
+    "    \n",
+    "    Returns:\n",
+    "        float: PSNR value\n",
+    "    \"\"\"\n",
+    "    # Ensure the values are in the correct range\n",
+    "    mse = torch.nn.functional.mse_loss(output, target)\n",
+    "    psnr = 20 * torch.log10(max_pixel / torch.sqrt(mse))\n",
+    "    return psnr.item()\n",
+    "\n",
+    "def visualize_reconstruction(original_image, reconstructed_image, psnr):\n",
+    "    \"\"\"\n",
+    "    Visualize original and reconstructed images\n",
+    "    \n",
+    "    Args:\n",
+    "        original_image (torch.Tensor): Original image tensor\n",
+    "        reconstructed_image (torch.Tensor): Reconstructed image tensor\n",
+    "        psnr (float): Peak Signal-to-Noise Ratio\n",
+    "    \"\"\"\n",
+    "    # Convert tensors to numpy for visualization\n",
+    "    original = original_image.squeeze().cpu().numpy()\n",
+    "    reconstructed = reconstructed_image.squeeze().cpu().numpy()\n",
+    "    \n",
+    "    # Create subplot\n",
+    "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n",
+    "    \n",
+    "    # Plot original image\n",
+    "    im1 = ax1.imshow(original, cmap='gray')\n",
+    "    ax1.set_title('Original Image')\n",
+    "    plt.colorbar(im1, ax=ax1)\n",
+    "    \n",
+    "    # Plot reconstructed image\n",
+    "    im2 = ax2.imshow(reconstructed, cmap='gray')\n",
+    "    ax2.set_title(f'Reconstructed Image\\nPSNR: {psnr:.2f} dB')\n",
+    "    plt.colorbar(im2, ax=ax2)\n",
+    "    \n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "def inference_single_image(reconstructor_model_path, denoiser_model_path, test_dicom_path):\n",
+    "    \"\"\"\n",
+    "    Perform inference on a single DICOM image using both Reconstructor and Denoiser models.\n",
+    "    \n",
+    "    Args:\n",
+    "        reconstructor_model_path (str): Path to the saved Reconstructor model weights\n",
+    "        denoiser_model_path (str): Path to the saved Denoiser model weights\n",
+    "        test_dicom_path (str): Path to the test DICOM file\n",
+    "    \"\"\"\n",
+    "    # Set device\n",
+    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "    \n",
+    "    # Initialize models\n",
+    "    reconstructor = Reconstructor().to(device)\n",
+    "    denoiser = Denoiser().to(device)\n",
+    "    \n",
+    "    # Load saved model weights\n",
+    "    reconstructor.load_state_dict(torch.load(reconstructor_model_path))\n",
+    "    denoiser.load_state_dict(torch.load(denoiser_model_path))\n",
+    "    \n",
+    "    reconstructor.eval()\n",
+    "    denoiser.eval()\n",
+    "    \n",
+    "    # Load and preprocess test image\n",
+    "    with torch.no_grad():\n",
+    "        test_image = load_dicom_image(test_dicom_path).to(device)\n",
+    "        \n",
+    "        # Perform reconstruction\n",
+    "        reconstructed_image = reconstructor(test_image)\n",
+    "        \n",
+    "        # Perform denoising on the reconstructed image\n",
+    "        denoised_image = denoiser(reconstructed_image)\n",
+    "        \n",
+    "        # Calculate PSNR for both original and denoised outputs\n",
+    "        psnr_reconstructed = calculate_psnr(reconstructed_image, test_image)\n",
+    "        psnr_denoised = calculate_psnr(denoised_image, test_image)\n",
+    "\n",
+    "        print(f\"PSNR (Reconstructed): {psnr_reconstructed:.2f} dB\")\n",
+    "        print(f\"PSNR (Denoised): {psnr_denoised:.2f} dB\")\n",
+    "        \n",
+    "        # Visualize results\n",
+    "        visualize_reconstruction(test_image, reconstructed_image, psnr_reconstructed)\n",
+    "        visualize_reconstruction(test_image, denoised_image, psnr_denoised)\n",
+    "\n",
+    "# Example usage\n",
+    "if __name__ == \"__main__\":\n",
+    "    # Paths to models and test image\n",
+    "    RECONSTRUCTOR_MODEL_PATH = \"./medium_reconstructor.pth\"  # Path to your saved Reconstructor model\n",
+    "    DENOISER_MODEL_PATH = \"./medium_denoiser.pth\"  # Path to your saved Denoiser model\n",
+    "    TEST_DICOM_PATH = \"./test.dcm\"  # Replace with actual path to test DICOM    \n",
+    "    # Run inference\n",
+    "    inference_single_image(RECONSTRUCTOR_MODEL_PATH, DENOISER_MODEL_PATH, TEST_DICOM_PATH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Larger Reconstructor U-Net (largeR)"
    ]
   },
   {
@@ -1691,38 +1834,41 @@
     "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
     "        self.conv3 = nn.Conv2d(out_channels, out_channels, 3, padding=1)\n",
     "        self.bn3 = nn.BatchNorm2d(out_channels)\n",
+    "        self.conv4 = nn.Conv2d(out_channels, out_channels, 3, padding=1)\n",
+    "        self.bn4 = 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",
     "        x = F.relu(self.bn3(self.conv3(x)))\n",
+    "        x = F.relu(self.bn4(self.conv4(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, 96)\n",
-    "        self.enc2 = UNetBlock(96, 192)\n",
-    "        self.enc3 = UNetBlock(192, 384)\n",
-    "        self.enc4 = UNetBlock(384, 768)\n",
-    "        self.enc5 = UNetBlock(768, 1536)\n",
+    "        self.enc1 = UNetBlock(in_channels, 64)\n",
+    "        self.enc2 = UNetBlock(64, 128)\n",
+    "        self.enc3 = UNetBlock(128, 256)\n",
+    "        self.enc4 = UNetBlock(256, 512)\n",
+    "        self.enc5 = UNetBlock(512, 1024)\n",
     "        \n",
     "        # Decoder with learned upsampling (transposed convolutions)\n",
     "\n",
-    "        self.upconv5 = nn.ConvTranspose2d(1536, 768, kernel_size=2, stride=2)  # Learnable upsampling\n",
-    "        self.dec5 = UNetBlock(768 + 768, 768)  # Adjust input channels after concatenation\n",
+    "        self.upconv5 = nn.ConvTranspose2d(1024, 512, kernel_size=2, stride=2)  # Learnable upsampling\n",
+    "        self.dec5 = UNetBlock(512 + 512, 512)  # Adjust input channels after concatenation\n",
     "\n",
-    "        self.upconv4 = nn.ConvTranspose2d(768, 384, kernel_size=2, stride=2)  # Learnable upsampling\n",
-    "        self.dec4 = UNetBlock(384 + 384, 384)  # Adjust input channels after concatenation\n",
+    "        self.upconv4 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2)  # Learnable upsampling\n",
+    "        self.dec4 = UNetBlock(256 + 256, 256)  # Adjust input channels after concatenation\n",
     "\n",
-    "        self.upconv3 = nn.ConvTranspose2d(384, 192, kernel_size=2, stride=2)  # Learnable upsampling\n",
-    "        self.dec3 = UNetBlock(192 + 192, 192)  # Adjust input channels after concatenation\n",
+    "        self.upconv3 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)  # Learnable upsampling\n",
+    "        self.dec3 = UNetBlock(128 + 128, 128)  # Adjust input channels after concatenation\n",
     "\n",
-    "        self.upconv2 = nn.ConvTranspose2d(192, 96, kernel_size=2, stride=2)  # Learnable upsampling\n",
-    "        self.dec2 = UNetBlock(96 + 96, 96)  # Adjust input channels after concatenation\n",
+    "        self.upconv2 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)  # Learnable upsampling\n",
+    "        self.dec2 = UNetBlock(64 + 64, 64)  # Adjust input channels after concatenation\n",
     "\n",
-    "        self.dec1 = UNetBlock(96, out_channels)  # Final output\n",
+    "        self.dec1 = UNetBlock(64, out_channels)  # Final output\n",
     "\n",
     "        self.pool = nn.MaxPool2d(2, 2)\n",
     "    \n",
@@ -1737,30 +1883,22 @@
     "        # Decoder path with learned upsampling and skip connections\n",
     "\n",
     "        d5 = self.upconv5(e5)  # Learnable upsampling\n",
-    "        # if d5.size(2) != e4.size(2) or d5.size(3) != e4.size(3):\n",
-    "        #     # Resize e4 to match d5's dimensions\n",
-    "        #     e4 = F.interpolate(e4, size=(d5.size(2), d5.size(3)), mode='nearest')\n",
+    "\n",
     "        d5 = torch.cat([d5, e4], dim=1)  # Concatenate with encoder features\n",
     "        d5 = checkpoint(self.dec5, d5)\n",
     "\n",
     "        d4 = self.upconv4(d5)  # Learnable upsampling\n",
-    "        # if d4.size(2) != e2.size(2) or d4.size(3) != e2.size(3):\n",
-    "        #     # Resize e3 to match d4's dimensions\n",
-    "        #     e3 = F.interpolate(e3, size=(d4.size(2), d4.size(3)), mode='nearest')\n",
+    "\n",
     "        d4 = torch.cat([d4, e3], dim=1)  # Concatenate with encoder features\n",
     "        d4 = checkpoint(self.dec4, d4)\n",
     "\n",
     "        d3 = self.upconv3(d4)  # Learnable upsampling\n",
-    "        # if d3.size(2) != e2.size(2) or d3.size(3) != e2.size(3):\n",
-    "        #     # Resize e2 to match d3's dimensions\n",
-    "        #     e2 = F.interpolate(e2, size=(d3.size(2), d3.size(3)), mode='nearest')\n",
+    "\n",
     "        d3 = torch.cat([d3, e2], dim=1)  # Concatenate with encoder features\n",
     "        d3 = checkpoint(self.dec3, d3)\n",
     "\n",
     "        d2 = self.upconv2(d3)  # Learnable upsampling\n",
-    "        # if d2.size(2) != e1.size(2) or d2.size(3) != e1.size(3):\n",
-    "        #     # Resize e1 to match d2's dimensions\n",
-    "        #     e1 = F.interpolate(e1, size=(d2.size(2), d2.size(3)), mode='nearest')\n",
+    "\n",
     "        d2 = torch.cat([d2, e1], dim=1)  # Concatenate with encoder features\n",
     "        d2 = checkpoint(self.dec2, d2)\n",
     "        \n",
@@ -1818,7 +1956,6 @@
     "    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",
@@ -1903,8 +2040,8 @@
     "        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",
+    "        avg_reconstructor_val_loss, avg_reconstructor_val_psnr = calculate_loss_and_psnr(reconstructor, val_dataloader, reconstructor_criterion)\n",
+    "        avg_denoiser_val_loss, avg_denoiser_val_psnr = 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",
@@ -1916,20 +2053,154 @@
     "        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",
+    "            print(f\"Reconstructor model saved with improved validation loss: {avg_reconstructor_val_loss:.4f} and PSNR: {avg_reconstructor_val_psnr}\")\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",
+    "            print(f\"Denoiser model saved with improved validation loss: {avg_denoiser_val_loss:.4f} and PSNR: {avg_denoiser_val_psnr}\")\n",
     "    \n",
     "    return reconstructor, denoiser\n",
     "\n",
     "# Example usage with train and validation directories\n",
     "reconstructor_model, denoiser_model = train_reconstructor_and_denoiser(\n",
-    "    r\"D:\\TCIA_Split\\train\", r\"D:\\TCIA_Split\\val\", epochs=50, batch_size=1, grad_accumulation_steps=64\n",
+    "    \"./TCIA_Split/train\", \"./TCIA_Split/val\", epochs=50, batch_size=8, grad_accumulation_steps=8\n",
     ")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### largeR Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import pydicom\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "\n",
+    "# Import the models from the previous script\n",
+    "# Assuming they are defined or imported correctly\n",
+    "\n",
+    "def load_dicom_image(dicom_path):\n",
+    "    \"\"\"\n",
+    "    Load and normalize a DICOM image\n",
+    "    \n",
+    "    Args:\n",
+    "        dicom_path (str): Path to the DICOM file\n",
+    "    \n",
+    "    Returns:\n",
+    "        torch.Tensor: Normalized image tensor\n",
+    "    \"\"\"\n",
+    "    # Read DICOM file\n",
+    "    dcm = pydicom.dcmread(dicom_path)\n",
+    "    image = dcm.pixel_array.astype(float)\n",
+    "    \n",
+    "    # Normalize image\n",
+    "    image = (image - image.min()) / (image.max() - image.min())\n",
+    "    \n",
+    "    # Convert to tensor\n",
+    "    image_tensor = torch.from_numpy(image).float().unsqueeze(0).unsqueeze(0)  # Add batch and channel dimensions\n",
+    "    return image_tensor\n",
+    "\n",
+    "def calculate_psnr(output, target, max_pixel=1.0):\n",
+    "    \"\"\"\n",
+    "    Calculate Peak Signal-to-Noise Ratio (PSNR)\n",
+    "    \n",
+    "    Args:\n",
+    "        output (torch.Tensor): Reconstructed image\n",
+    "        target (torch.Tensor): Original image\n",
+    "        max_pixel (float): Maximum pixel value\n",
+    "    \n",
+    "    Returns:\n",
+    "        float: PSNR value\n",
+    "    \"\"\"\n",
+    "    # Ensure the values are in the correct range\n",
+    "    mse = torch.nn.functional.mse_loss(output, target)\n",
+    "    psnr = 20 * torch.log10(max_pixel / torch.sqrt(mse))\n",
+    "    return psnr.item()\n",
+    "\n",
+    "def visualize_reconstruction(original_image, reconstructed_image, psnr):\n",
+    "    \"\"\"\n",
+    "    Visualize original and reconstructed images\n",
+    "    \n",
+    "    Args:\n",
+    "        original_image (torch.Tensor): Original image tensor\n",
+    "        reconstructed_image (torch.Tensor): Reconstructed image tensor\n",
+    "        psnr (float): Peak Signal-to-Noise Ratio\n",
+    "    \"\"\"\n",
+    "    # Convert tensors to numpy for visualization\n",
+    "    original = original_image.squeeze().cpu().numpy()\n",
+    "    reconstructed = reconstructed_image.squeeze().cpu().numpy()\n",
+    "    \n",
+    "    # Create subplot\n",
+    "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n",
+    "    \n",
+    "    # Plot original image\n",
+    "    im1 = ax1.imshow(original, cmap='gray')\n",
+    "    ax1.set_title('Original Image')\n",
+    "    plt.colorbar(im1, ax=ax1)\n",
+    "    \n",
+    "    # Plot reconstructed image\n",
+    "    im2 = ax2.imshow(reconstructed, cmap='gray')\n",
+    "    ax2.set_title(f'Reconstructed Image\\nPSNR: {psnr:.2f} dB')\n",
+    "    plt.colorbar(im2, ax=ax2)\n",
+    "    \n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "def inference_single_image(reconstructor_model_path, test_dicom_path):\n",
+    "    \"\"\"\n",
+    "    Perform inference on a single DICOM image using both Reconstructor and Denoiser models.\n",
+    "    \n",
+    "    Args:\n",
+    "        reconstructor_model_path (str): Path to the saved Reconstructor model weights\n",
+    "        denoiser_model_path (str): Path to the saved Denoiser model weights\n",
+    "        test_dicom_path (str): Path to the test DICOM file\n",
+    "    \"\"\"\n",
+    "    # Set device\n",
+    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "    \n",
+    "    # Initialize models\n",
+    "    reconstructor = Reconstructor().to(device)\n",
+    "    \n",
+    "    # Load saved model weights\n",
+    "    reconstructor.load_state_dict(torch.load(reconstructor_model_path))\n",
+    "    \n",
+    "    reconstructor.eval()\n",
+    "    \n",
+    "    # Load and preprocess test image\n",
+    "    with torch.no_grad():\n",
+    "        test_image = load_dicom_image(test_dicom_path).to(device)\n",
+    "        \n",
+    "        # Perform reconstruction\n",
+    "        reconstructed_image = reconstructor(test_image)\n",
+    "        \n",
+    "        \n",
+    "        # Calculate PSNR for both original and denoised outputs\n",
+    "        psnr_reconstructed = calculate_psnr(reconstructed_image, test_image)\n",
+    "\n",
+    "        print(f\"PSNR (Reconstructed): {psnr_reconstructed:.2f} dB\")\n",
+    "        \n",
+    "        # Visualize results\n",
+    "        visualize_reconstruction(test_image, reconstructed_image, psnr_reconstructed)\n",
+    "\n",
+    "# Example usage\n",
+    "if __name__ == \"__main__\":\n",
+    "    # Paths to models and test image\n",
+    "    RECONSTRUCTOR_MODEL_PATH = \"./large_reconstructor.pth\"  # Path to your saved Reconstructor model\n",
+    "    TEST_DICOM_PATH = \"./test.dcm\"  # Replace with actual path to test DICOM    \n",
+    "    # Run inference\n",
+    "    inference_single_image(RECONSTRUCTOR_MODEL_PATH, TEST_DICOM_PATH)"
+   ]
   }
  ],
  "metadata": {
@@ -1948,7 +2219,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,