From 0686db3bd36909cc3b322415f8e4373fc4fa3f10 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 12 Oct 2025 13:28:19 +1000
Subject: [PATCH 01/15] initial

checking out the topic-recognition branch within your fork
---
 .idea/.gitignore                               |  3 +++
 .idea/PatternAnalysis-2025.iml                 |  8 ++++++++
 .idea/inspectionProfiles/Project_Default.xml   | 12 ++++++++++++
 .idea/inspectionProfiles/profiles_settings.xml |  6 ++++++
 .idea/misc.xml                                 |  4 ++++
 .idea/modules.xml                              |  8 ++++++++
 .idea/vcs.xml                                  |  6 ++++++
 7 files changed, 47 insertions(+)
 create mode 100644 .idea/.gitignore
 create mode 100644 .idea/PatternAnalysis-2025.iml
 create mode 100644 .idea/inspectionProfiles/Project_Default.xml
 create mode 100644 .idea/inspectionProfiles/profiles_settings.xml
 create mode 100644 .idea/misc.xml
 create mode 100644 .idea/modules.xml
 create mode 100644 .idea/vcs.xml

diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 000000000..26d33521a
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml
diff --git a/.idea/PatternAnalysis-2025.iml b/.idea/PatternAnalysis-2025.iml
new file mode 100644
index 000000000..d0876a78d
--- /dev/null
+++ b/.idea/PatternAnalysis-2025.iml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 000000000..0318588e8
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,12 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="website.template._init_.*" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml
new file mode 100644
index 000000000..105ce2da2
--- /dev/null
+++ b/.idea/inspectionProfiles/profiles_settings.xml
@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 000000000..dc9ea4906
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 000000000..33e468890
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/PatternAnalysis-2025.iml" filepath="$PROJECT_DIR$/.idea/PatternAnalysis-2025.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 000000000..94a25f7f4
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

From e20a387c6111600e55041eb5e8a5f970b21984b8 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 12 Oct 2025 13:38:59 +1000
Subject: [PATCH 02/15] adding files

added different .py files according to the task sheet and added a README.md file
---
 recognition/GAN_model_47508042/README.md  | 0
 recognition/GAN_model_47508042/dataset.py | 0
 recognition/GAN_model_47508042/modules.py | 0
 recognition/GAN_model_47508042/predict.py | 0
 recognition/GAN_model_47508042/train.py   | 0
 5 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 recognition/GAN_model_47508042/README.md
 create mode 100644 recognition/GAN_model_47508042/dataset.py
 create mode 100644 recognition/GAN_model_47508042/modules.py
 create mode 100644 recognition/GAN_model_47508042/predict.py
 create mode 100644 recognition/GAN_model_47508042/train.py

diff --git a/recognition/GAN_model_47508042/README.md b/recognition/GAN_model_47508042/README.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/recognition/GAN_model_47508042/dataset.py b/recognition/GAN_model_47508042/dataset.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/recognition/GAN_model_47508042/modules.py b/recognition/GAN_model_47508042/modules.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/recognition/GAN_model_47508042/predict.py b/recognition/GAN_model_47508042/predict.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/recognition/GAN_model_47508042/train.py b/recognition/GAN_model_47508042/train.py
new file mode 100644
index 000000000..e69de29bb

From ed69a15a074da7ba58f7da7cefe080f1b712e76d Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 12 Oct 2025 13:40:00 +1000
Subject: [PATCH 03/15] renaming folder

renamed the folder from GAN_model_47508042 to GANmodel_47508042
---
 recognition/{GAN_model_47508042 => GANmodel_47508042}/README.md  | 0
 recognition/{GAN_model_47508042 => GANmodel_47508042}/dataset.py | 0
 recognition/{GAN_model_47508042 => GANmodel_47508042}/modules.py | 0
 recognition/{GAN_model_47508042 => GANmodel_47508042}/predict.py | 0
 recognition/{GAN_model_47508042 => GANmodel_47508042}/train.py   | 0
 5 files changed, 0 insertions(+), 0 deletions(-)
 rename recognition/{GAN_model_47508042 => GANmodel_47508042}/README.md (100%)
 rename recognition/{GAN_model_47508042 => GANmodel_47508042}/dataset.py (100%)
 rename recognition/{GAN_model_47508042 => GANmodel_47508042}/modules.py (100%)
 rename recognition/{GAN_model_47508042 => GANmodel_47508042}/predict.py (100%)
 rename recognition/{GAN_model_47508042 => GANmodel_47508042}/train.py (100%)

diff --git a/recognition/GAN_model_47508042/README.md b/recognition/GANmodel_47508042/README.md
similarity index 100%
rename from recognition/GAN_model_47508042/README.md
rename to recognition/GANmodel_47508042/README.md
diff --git a/recognition/GAN_model_47508042/dataset.py b/recognition/GANmodel_47508042/dataset.py
similarity index 100%
rename from recognition/GAN_model_47508042/dataset.py
rename to recognition/GANmodel_47508042/dataset.py
diff --git a/recognition/GAN_model_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
similarity index 100%
rename from recognition/GAN_model_47508042/modules.py
rename to recognition/GANmodel_47508042/modules.py
diff --git a/recognition/GAN_model_47508042/predict.py b/recognition/GANmodel_47508042/predict.py
similarity index 100%
rename from recognition/GAN_model_47508042/predict.py
rename to recognition/GANmodel_47508042/predict.py
diff --git a/recognition/GAN_model_47508042/train.py b/recognition/GANmodel_47508042/train.py
similarity index 100%
rename from recognition/GAN_model_47508042/train.py
rename to recognition/GANmodel_47508042/train.py

From 2a47d329f611dbaab3e76a30145c0156d9b55c6d Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 12 Oct 2025 15:54:15 +1000
Subject: [PATCH 04/15] updated modules.py

added imports and a rough outline for the encoder and decoder class to modules.py
---
 recognition/GANmodel_47508042/modules.py | 32 ++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index e69de29bb..0fa15492b 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -0,0 +1,32 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Encoder(nn.Module):
+    def __init__(self, in_ch=1, hidden=128, z_channels=64):
+        super().__init__()
+        self.enc = nn.Sequential(
+            nn.Conv2d(in_ch, hidden//2, 4, 2, 1),
+            nn.ReLU(True),
+            nn.Conv2d(hidden//2, hidden, 4, 2, 1),
+            nn.ReLU(True),
+            nn.Conv2d(hidden, z_channels, 3, 1, 1),
+        )
+        
+    def forward(self, x):
+        return self.enc(x)
+
+class Decoder(nn.Module):
+    def __init__(self, out_ch=1, hidden=128, z_channels=64):
+        super().__init__()
+        self.dec = nn.Sequential(
+            nn.Conv2d(z_channels, hidden, 3, 1, 1),
+            nn.ReLU(True),
+            nn.ConvTranspose2d(hidden, hidden//2, 4, 2, 1),
+            nn.ReLU(True),
+            nn.ConvTranspose2d(hidden//2, out_ch, 4, 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, z):
+        return self.dec(z)
\ No newline at end of file

From dcdca518df38e0b3db1dced0973d39405dfcc18d Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 12 Oct 2025 17:35:51 +1000
Subject: [PATCH 05/15] readme

created a rough readme template to be used at a later time
---
 recognition/GANmodel_47508042/README.md  | 15 +++++++++++++++
 recognition/GANmodel_47508042/modules.py |  2 +-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/recognition/GANmodel_47508042/README.md b/recognition/GANmodel_47508042/README.md
index e69de29bb..082a92e42 100644
--- a/recognition/GANmodel_47508042/README.md
+++ b/recognition/GANmodel_47508042/README.md
@@ -0,0 +1,15 @@
+# Pattern Recognition - Generative Model using VQVAE
+
+This project uses VQVAE to create a generative model of the HipMRI Study on Prostate Cancer. Accuracy of this model is
+measured to be over 0.6.
+
+# Author
+* Justin Teng - 47508042
+
+# Table of Contents
+1. Project Highlights
+
+
+# Project Highlights
+
+# Authors and Acknowledgements
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index 0fa15492b..60729f473 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -12,7 +12,7 @@ def __init__(self, in_ch=1, hidden=128, z_channels=64):
             nn.ReLU(True),
             nn.Conv2d(hidden, z_channels, 3, 1, 1),
         )
-        
+
     def forward(self, x):
         return self.enc(x)
 

From 9afadb9f165e947337e017656e2f680a8422e2e4 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Tue, 14 Oct 2025 13:05:52 +1000
Subject: [PATCH 06/15] vectorquantizer

created a rough template for a vector quantizer.
---
 recognition/GANmodel_47508042/modules.py | 46 +++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index 60729f473..b812aac03 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -29,4 +29,48 @@ def __init__(self, out_ch=1, hidden=128, z_channels=64):
         )
 
     def forward(self, z):
-        return self.dec(z)
\ No newline at end of file
+        return self.dec(z)
+
+class VectorQuantizer(nn.Module):
+    def __init__(self, num_embeddings=512, embedding_dim=64, beta=0.25):
+        super().__init__()
+        self.num_embeddings = num_embeddings
+        self.embedding_dim = embedding_dim
+        self.beta = beta
+
+        self.embedding = nn.Embedding(self.num_embeddings, self.embedding_dim)
+        nn.init.uniform_(self.embedding.weight, -1.0 / self.num_embeddings, 1.0 / self.num_embeddings)
+
+    def forward(self, z):
+        z_perm = z.permute(0, 2, 3, 1).contagious()
+        flat_z = z_perm.view(-1, self.embedding_dim)
+
+        # compute distances
+        distances = (
+            torch.sum(flat_z**2, dim=1, keepdim=True)
+            + torch.sum(self.embedding.weight**2, dim=1)
+            - 2 * torch.matmul(flat_z, self.embedding.weight.t())
+        )
+
+        encoding_indices = torch.argmin(distances, dim=1).unsqueeze(1)
+        encodings = torch.zeros(encoding_indices.size(0), self.num_embeddings, device=z.device)
+        encodings.scatter_(1, encoding_indices, 1)
+
+        # quantized
+        quantized = torch.matmul(encodings, self.embeddings.weights)
+        quantized = quantized.view(z_perm.shape)
+        quantized = quantized.permute(0, 3, 1, 2).contiguous()
+
+        # losses
+        e_latent_loss = F.mse_loss(quantized.detach(), z)
+        q_latent_loss = F.mse_loss(quantized, z.detach())
+        loss = q_latent_loss + self.beta * e_latent_loss
+
+        # estimator
+        quantized = z + (quantized - z).detach()
+
+        # visualisation
+        encoding_indices = encoding_indices.view(z.shape[0], z.shape[2], z.shape[3])
+        return quantized, loss, encoding_indices
+
+

From 1aa41ed7033d9001cfdb3e3b25b1a809fa518634 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Tue, 14 Oct 2025 16:22:51 +1000
Subject: [PATCH 07/15] VQVAE

created a rough template for the VQVAE class
---
 recognition/GANmodel_47508042/modules.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index b812aac03..a188f28f2 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -73,4 +73,17 @@ def forward(self, z):
         encoding_indices = encoding_indices.view(z.shape[0], z.shape[2], z.shape[3])
         return quantized, loss, encoding_indices
 
+class VQVAE(nn.Module):
+    def __init__(self, in_ch=1, hidden=128, z_channels=64, num_embeddings=512, embedding_dim=64, beta=0.25):
+        super().__init__()
+        assert z_channels == embedding_dim
+        self.encoder = Encoder(in_ch, hidden, z_channels)
+        self.vq = VectorQuantizer(num_embeddings=num_embeddings, embedding_dim=embedding_dim, beta=beta)
+        self.decoder = Decoder(in_ch, hidden, z_channels)
 
+    def forward(self, x):
+        z_e = self.encoder(x)
+        quantized, vq_loss, indices = self.vq(z_e)
+        x_recon = self.decoder(quantized)
+        return x_recon, vq_loss, indices
+    
\ No newline at end of file

From a0c4b3efdcacb1c7c47e5e77ffa073a09ff8d177 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Wed, 15 Oct 2025 15:38:26 +1000
Subject: [PATCH 08/15] readme update

updated the readme from the previous format as i realised i wont have too much considering i only have a couple files, hence i removed the contents part and author since i am the only one doing this project
---
 recognition/GANmodel_47508042/README.md  | 28 +++++++++++++++---------
 recognition/GANmodel_47508042/modules.py |  1 -
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/recognition/GANmodel_47508042/README.md b/recognition/GANmodel_47508042/README.md
index 082a92e42..f5d3e43b3 100644
--- a/recognition/GANmodel_47508042/README.md
+++ b/recognition/GANmodel_47508042/README.md
@@ -1,15 +1,23 @@
 # Pattern Recognition - Generative Model using VQVAE
 
-This project uses VQVAE to create a generative model of the HipMRI Study on Prostate Cancer. Accuracy of this model is
-measured to be over 0.6.
+## Overview
+This project uses VQVAE to create a generative model of the HipMRI Study on Prostate Cancer. The goal is to produce
+reasonably clear images and reach SSIM > 0.6 on testing.
 
-# Author
-* Justin Teng - 47508042
+## Files
+ - 'dataset.py' - Encoder, Decoder, VectorQuantizer, VQVAE model
+ - 'modules.py' - 'HipMRIDataset' loader
+ - 'predict.py' - load best model and produce reconstructions
+ - 'train.py' -  training loop, validation, checkpointing, plots
 
-# Table of Contents
-1. Project Highlights
+## Requirements
+- Python 3.8+
+- PyTorch
+- torchvision
+- matplotlib
+- scikit-image
+- numpy
 
-
-# Project Highlights
-
-# Authors and Acknowledgements
\ No newline at end of file
+Install:
+```bash
+pip install torch torchvision matplotlib scikit-image numpy
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index a188f28f2..4aea23d59 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -86,4 +86,3 @@ def forward(self, x):
         quantized, vq_loss, indices = self.vq(z_e)
         x_recon = self.decoder(quantized)
         return x_recon, vq_loss, indices
-    
\ No newline at end of file

From ad7f0797ef1d0e39cbd8b9d486a8b32ebc7a176e Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Wed, 15 Oct 2025 18:12:22 +1000
Subject: [PATCH 09/15] dataset.py & train.py

added classes to dataset.py and train.py (code unfinished)
---
 recognition/GANmodel_47508042/dataset.py | 50 ++++++++++++++++++++++++
 recognition/GANmodel_47508042/train.py   | 12 ++++++
 2 files changed, 62 insertions(+)

diff --git a/recognition/GANmodel_47508042/dataset.py b/recognition/GANmodel_47508042/dataset.py
index e69de29bb..3968b1312 100644
--- a/recognition/GANmodel_47508042/dataset.py
+++ b/recognition/GANmodel_47508042/dataset.py
@@ -0,0 +1,50 @@
+import os
+import numpy as np
+import nibabel as nib
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+
+class HipMRIDataset(Dataset):
+    def __init__(self, root_dir, image_size=256, transform=None, max_slices_per_volume=None, recursive=True):
+        self.root_dir = root_dir
+        self.image_size = image_size
+        self.max_slices = max_slices_per_volume
+        self.recursive = recursive
+
+        # finding files
+        self.files = self.collect_files()
+        if len(self.files) == 0:
+            raise ValueError(f"no files found in {root_dir}")
+
+        # transform
+        if transform is None:
+            self.transform = transforms.Compose([
+                transforms.Resize((image_size, image_size)),
+                transforms.ToTensor(),
+            ])
+        else:
+            self.transform = transform
+
+        # pre-index slices
+        self.index_map = []
+        for f_idx, path in enumerate(self.files):
+            vol = nib.load(path).get_fdata()
+            depth = vol.shape[2]
+            n_slices = depth if self.max_slices is None else min(depth, self.max_slices)
+            for si in range(n_slices):
+                self.index_map.append((f_idx, si))
+
+    def collect_files(self):
+        exists = ('.nii', '.nii.gz')
+        files = []
+        if self.recursive:
+            for root, _, filenames in os.walk(self.root_dir):
+                for fn in filenames:
+                    if fn.lower().endswith(exists):
+                        files.append(os.path.join(root, fn))
+        else:
+            for fn in os.listdir(self.root_dir):
+                if fn.lower().endswith(exists):
+                    files.append(os.path.join(self.root_dir, fn))
+        return sorted(files)
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/train.py b/recognition/GANmodel_47508042/train.py
index e69de29bb..8af6c24e1 100644
--- a/recognition/GANmodel_47508042/train.py
+++ b/recognition/GANmodel_47508042/train.py
@@ -0,0 +1,12 @@
+import os
+import argparse
+import torch
+from torch import optim
+from torch.utils.data import DataLoader, random_split
+import torch.nn.functional as F
+from tqdm import tqdm
+from modules import VQVAE
+
+def train_loop(args):
+    device = torch.device('cuda' if torch.cude.is_available() else 'cpu')
+    print("device:", device)

From 4093547f528a2fb3a4a96e11df823a1b87adb314 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Fri, 17 Oct 2025 18:19:21 +1000
Subject: [PATCH 10/15] changes made and added a utils.py

added on to the dataset and train files. added a utils file to have some helper functions as well
---
 .../__pycache__/dataset.cpython-310.pyc       | Bin 0 -> 2292 bytes
 .../__pycache__/modules.cpython-310.pyc       | Bin 0 -> 3446 bytes
 recognition/GANmodel_47508042/dataset.py      |  23 ++++-
 recognition/GANmodel_47508042/train.py        |  95 ++++++++++++++++++
 recognition/GANmodel_47508042/utils.py        |  50 +++++++++
 5 files changed, 167 insertions(+), 1 deletion(-)
 create mode 100644 recognition/GANmodel_47508042/__pycache__/dataset.cpython-310.pyc
 create mode 100644 recognition/GANmodel_47508042/__pycache__/modules.cpython-310.pyc
 create mode 100644 recognition/GANmodel_47508042/utils.py

diff --git a/recognition/GANmodel_47508042/__pycache__/dataset.cpython-310.pyc b/recognition/GANmodel_47508042/__pycache__/dataset.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ffd77ddd11d8477c77a1156e4ff17dd7040ab22
GIT binary patch
literal 2292
zcmZ8i-ER~(5V!aH_CA1+M0|*rLe=V2NTL7&RS1CqQKUAa6#B5DvX-;&vX{Nx!}dXP
z+LKU2-`YM`sw&;RRI1d!$dBz4kA1CL=!}oh1g~~>Y>&sYp5OdjHk&blcJ{BoHh-@X
z@+WroHxD}3;Z^rQaKdR$lKGb=j_tdN2VW=m2SE~0oOAPV5G9e-y}UMvlbDh_g!?>r
zL3kjdT{o$7`W0!1FTpF>Xj9|g9i%-0N_Z>PsS+C0Sj)6f-BJ!z2krJZ7dqGBRVyF_
zNhl`}PlJ2he?b$M2RwX1AhL+p;Oq04*Wnv*2X<|m=4aXPi~D!qZ1s{*2;xB}09Sjh
z0SfkS!mA93idKY?$^l6$52RE1Al-^gy%_<`*Fi=4{x0Qo%aQNvkUJIqnf&7H(r;<y
zaxx<Ff{vy&cw_M6be$Omy*?v7(7;2Za4Yb~8a?#a)UCO{TjZN_kDN&`3H71r;VPWb
z>5&<kL{-#Z;O=oUsev8j0{lO$YK5<lR(539nZ$arigzh^h$nThYEGA`psM4}lssWi
zu5kkA;cZAb05V=E%G2E}7wUAk92NX@R-At6z(jl5M6xV3<C!#ZhKXV-8w(Q;(ru>l
ztRs}ENzoZel|2=v*(vi}bTqThj6eUlxhPEhb()XFZ7EAB5n4%jvm6XdB}{N%pwA?F
zP(BcaDy6BtO~0vS1sB_FkPb~v6r+KVsTRg9vd6~D%aog1Pr!B@pksWsnGRuckQK%U
z0QJCkIvk3Ew;RS&BJauwc9wv4B9DMDOaK1{8w$yumN{-w$N2m%%lNkOhN<2(F3cF8
zi=p03qGIpQ9hLn?<Og8=_rukPN=UWZA1R#`tGCK$1%{_q@1<G`S==bnd`D&K{QBDZ
zrByhwvR7m}D~r`TH#P<(7dg9l`O?~zwTtVk_%l!kE5jWVF_wWHV;HkK2O^;JCw5!3
zMI+av4H$`E1%BWzz(`C_z{mo1UVHzHmk*$QWzSg$lfKtNQ1DnR-hTpx(+Ta73E;g?
z<ate}sJS!5(#c2e#GQB(zw)7XbP`kn*1*)S=#0vbD`y&L+7G7@pgEY$v9|c6sR8x7
zQ1##o@j3Uk_|ED(`&NU^+w~XrR=1svwlnrtiYyz4C|7#pcHJh+IHfY)voznb88&`i
zJ`>VJkb3nj)0^@H{Fgih!g&1>;1TAT(g^AR@TLWChw>!O24Wi~lx$j4gubE7)DXu-
zIsmXc-NGh(F3zA^B#e*XRquiDs0Zm-rV*rKkvh+vS5bKQ-xiEG&m%fMc`zXd%H=>-
zFhf{@HY-Tf8knI^@f6z>&Ox?dOfG<EQycm_QJIi2h?%jAV4~1dOvg(HcYkBi!P&ir
z(D&iB`~C_FqM)M33Gk3J0gmd^$^qu_v@>-p4;TsZk9e5+z=i%am=VV^RuxvkF~HIm
zk)P<WA5}ic8h3thCQ$)BoSoa8w2TI~2l)=~6_AzNwd|(jX}zj(cacmRu(~+|lucrY
zp(Vcr_H9+M?Z=kMdY^v3_Q#Jqx3A%y!u8HjynGGuw-4D<vKf_&Fd&yuETcFE0_Y;$
zHcl}#@mR=Gu{_%nChS7>>I>@<&nBsLWjRQtOm~1#6uLJ4C@b_8%OZe5iyhxmRT3ju
zplX4(lDehHdB?&}B1Y`K@&az|6>!HTp*36Q#?1!3cN1A>3@9$sV!+sCSfem%tn(IB
zIac~%XBi&g0D#{3_`4~7ySD8~yw)~09<)Q`6~r@RCT0xiX9OWL(_rk$D9z_H@+??e
zaLYB+uA)G$+b7Oo7vX{gq7bGL;4C^7wHmG+Z#U$JFlv0D?%|F^FeV|8cluc5HXFvh
zclUF9%I2^xWoL6`q_bSDAO}hpm)7m@(@X(b+MB~V-WP<82_rGl)%mYn!|G93ArXn7
K6dU$gbp8YM;yk+m

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/__pycache__/modules.cpython-310.pyc b/recognition/GANmodel_47508042/__pycache__/modules.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04d604bdf628dc43751046950cd790521b6a56bd
GIT binary patch
literal 3446
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
JTbq~O`X8K1=2rj!

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/dataset.py b/recognition/GANmodel_47508042/dataset.py
index 3968b1312..47c65111f 100644
--- a/recognition/GANmodel_47508042/dataset.py
+++ b/recognition/GANmodel_47508042/dataset.py
@@ -47,4 +47,25 @@ def collect_files(self):
             for fn in os.listdir(self.root_dir):
                 if fn.lower().endswith(exists):
                     files.append(os.path.join(self.root_dir, fn))
-        return sorted(files)
\ No newline at end of file
+        return sorted(files)
+
+    def __len__(self):
+        return len(self.index_map)
+
+    def __getitem__(self, index):
+        file_index, slice_index = self.index_map[index]
+        path = self.files[file_index]
+        vol = nib.load(path).get_fdata()
+        min, max = vol.min(), vol.max()
+        if max - min < 1e-8:
+            norm = np.zeros_like(vol, dtype=np.float32)
+        else:
+            norm = (vol - min) / (max - min)
+
+        slice2d = norm[:, :, slice_index]
+        # convert to uint8 image then to PIL so transform works reliably
+        img = Image.fromarray((slice2d * 255).astype(np.uint8))
+        if self.transform:
+            img = self.transform(img)  # tensor in [0,1}, shape (C,H,W)
+        return img
+
diff --git a/recognition/GANmodel_47508042/train.py b/recognition/GANmodel_47508042/train.py
index 8af6c24e1..ab0e79499 100644
--- a/recognition/GANmodel_47508042/train.py
+++ b/recognition/GANmodel_47508042/train.py
@@ -5,8 +5,103 @@
 from torch.utils.data import DataLoader, random_split
 import torch.nn.functional as F
 from tqdm import tqdm
+
 from modules import VQVAE
+from dataset import HipMRIDataset
+from utils import ensure_dir, save_pair_grid, batch_ssim
 
 def train_loop(args):
     device = torch.device('cuda' if torch.cude.is_available() else 'cpu')
     print("device:", device)
+
+    ds = HipMRIDataset(args.data_root, image_size=args.image_size, max_slices_per_volume=args.max_slices, recursive=True)
+    # split training and testing 90/10
+    n_val = max(1, int(len(ds) * args.val_frac))
+    n_train = len(ds) - n_val
+    train_set, val_set = random_split(ds, [n_train, n_val])
+
+    train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
+    val_loader = DataLoader(val_set, batch_size=args.batch_size, shuffle=False, num_workers=args.workers)
+
+    model = VQVAE(in_ch=1, hidden=args.hidden, z_channels=args.z_channels, num_embeddings=args.num_embeddings, beta=args.beta).to(device)
+    optimiser = optim.Adam(model.parameters90, lr=args.lr)
+
+    '''ensure_dir(args.output_dir)'''
+    best_ssim = 0.0
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        train_loss = 0.0
+        for batch in tqdm(train_loader, desc=f'Epoch {epoch}/{args.epochs} [train]'):
+            x = batch.to(device)
+            x_recon, vq_loss, _ = model(x)
+            recon_loss = F.mse_loss(x_recon,x)
+            loss = recon_loss + vq_loss
+
+            optimiser.zero_grad()
+            loss.backward()
+            optimiser.step()
+
+            train_loss += loss.item() * x.size(0)
+
+        train_loss = train_loss / len(train_loader.dataset)
+
+        # validation
+        model.eval()
+        val_loss = 0.0
+        ssim_scores = []
+        with torch.no_grad():
+            for i, batch in enumerate(tqdm(val_loader, desc=f"Epoch {epoch}/{args.epochs} [val]")):
+                x = batch.to(device)
+                x_recon, vq_loss, _ = model(x)
+                recon_loss = F.mse_loss(x_recon, x)
+                loss = recon_loss + vq_loss
+                val_loss += loss.item() * x.size(0)
+                ssim_scores.append(batch_ssim(x, x_recon))
+
+                # save first validation batch reconstructions
+                if i == 0:
+                    save_pair_grid(x.cpu(), x_recon.cpu(),
+                                   os.path.join(args.output_dir, f"epoch_{epoch:03d}_recon.png"), n=min(4, x.size(0)))
+
+        val_loss = val_loss / len(val_loader.dataset)
+        mean_ssim = float(sum(ssim_scores) / len(ssim_scores))
+
+        print(f"Epoch {epoch}  TrainLoss={train_loss:.4f}  ValLoss={val_loss:.4f}  ValSSIM={mean_ssim:.4f}")
+
+        # checkpoint by SSIM
+        if mean_ssim > best_ssim:
+            best_ssim = mean_ssim
+            torch.save({
+                'epoch': epoch,
+                'model_state': model.state_dict(),
+                'optimizer_state': optimiser.state_dict(),
+                'ssim': best_ssim
+            }, os.path.join(args.output_dir, "best_checkpoint.pth"))
+            print(f"  Saved best model (SSIM={best_ssim:.4f})")
+
+        # save periodic snapshot
+        if epoch % args.save_every == 0:
+            torch.save(model.state_dict(), os.path.join(args.output_dir, f"vqvae_epoch_{epoch}.pt"))
+
+    print("Training complete. Best SSIM:", best_ssim)
+
+    if __name__ == "__main__":
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--data_root", type=str, required=True)
+        parser.add_argument("--output_dir", type=str, default="outputs")
+        parser.add_argument("--image_size", type=int, default=256)
+        parser.add_argument("--epochs", type=int, default=40)
+        parser.add_argument("--batch_size", type=int, default=8)
+        parser.add_argument("--lr", type=float, default=2e-4)
+        parser.add_argument("--z_ch", type=int, default=64)
+        parser.add_argument("--hidden", type=int, default=128)
+        parser.add_argument("--num_embeddings", type=int, default=512)
+        parser.add_argument("--beta", type=float, default=0.25)
+        parser.add_argument("--max_slices", type=int, default=40)
+        parser.add_argument("--val_frac", type=float, default=0.10)
+        parser.add_argument("--workers", type=int, default=2)
+        parser.add_argument("--save_every", type=int, default=10)
+        args = parser.parse_args()
+        ensure_dir(args.output_dir)
+        train_loop(args)
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/utils.py b/recognition/GANmodel_47508042/utils.py
new file mode 100644
index 000000000..0b4f944f9
--- /dev/null
+++ b/recognition/GANmodel_47508042/utils.py
@@ -0,0 +1,50 @@
+"""
+utils.py
+Helper functions: save images, compute SSIM, create folders.
+"""
+
+import os
+import torch
+import matplotlib.pyplot as plt
+import numpy as np
+from skimage.metrics import structural_similarity as ssim
+
+def ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+def save_pair_grid(x_orig, x_rec, path, n=4):
+    """
+    Save a grid with n original / reconstructed pairs (first n in batch).
+    x_*: tensors (B, C, H, W) in [0,1]
+    """
+    ensure_dir(os.path.dirname(path))
+    B = x_orig.shape[0]
+    n = min(n, B)
+    fig, axes = plt.subplots(n, 2, figsize=(6, 3*n))
+    for i in range(n):
+        axes[i,0].imshow(x_orig[i].cpu().squeeze(), cmap='gray')
+        axes[i,0].set_title("Original")
+        axes[i,0].axis('off')
+        axes[i,1].imshow(x_rec[i].cpu().squeeze(), cmap='gray')
+        axes[i,1].set_title("Reconstruction")
+        axes[i,1].axis('off')
+    plt.tight_layout()
+    plt.savefig(path, dpi=150)
+    plt.close(fig)
+
+def batch_ssim(x, x_recon):
+    """
+    Compute mean SSIM across a batch. Assumes x and x_recon are (B,1,H,W) in [0,1].
+    """
+    x_np = x.detach().cpu().numpy()
+    xr_np = x_recon.detach().cpu().numpy()
+    scores = []
+    for i in range(x_np.shape[0]):
+        im1 = x_np[i,0]
+        im2 = xr_np[i,0]
+        try:
+            s = ssim(im1, im2, data_range=1.0)
+        except Exception:
+            s = 0.0
+        scores.append(s)
+    return float(np.mean(scores))

From 64965cd1756a55c667d4cd1acd3ef8b7d7395015 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 19 Oct 2025 11:51:20 +1000
Subject: [PATCH 11/15] updated predict.py

added 2 functions to predict.py
---
 recognition/GANmodel_47508042/predict.py | 36 ++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/recognition/GANmodel_47508042/predict.py b/recognition/GANmodel_47508042/predict.py
index e69de29bb..4039c1607 100644
--- a/recognition/GANmodel_47508042/predict.py
+++ b/recognition/GANmodel_47508042/predict.py
@@ -0,0 +1,36 @@
+import os
+import argparse
+import torch
+from torch.utils.data import DataLoader
+from dataset import HipMRIDataset
+from modules import VQVAE
+from utils import ensure_dir, save_pair_grid
+
+def visualise(checkpoint, data_root, output_dir, batch_size=8, max_slices=40):
+    device = torch.device('cude' if torch.cude.is_available() else 'cpu')
+    checkpoint = torch.load(checkpoint, map_location=device)
+    model = VQVAE(in_ch=1, hidden=128, z_ch=64, num_embeddings=512, beta=0.25).to(device)
+    model.load_state_dict(checkpoint['model_state'])
+    model.eval()
+
+    ds = HipMRIDataset(data_root, image_size=256, max_slices_per_volume=max_slices, recursive=True)
+    loader = DataLoader(ds, batch_size=batch_size, shuffle=False, num_workers=2)
+
+    ensure_dir(output_dir)
+    with torch.no_grad():
+        batch = next(iter(loader))
+        x = batch.to(device)
+        x_recon, _, indices = model(x)
+        save_pair_grid(x.cpu(), x_recon.cpu(), os.path.join(output_dir, 'pred_sample.png'))
+        print("saved reconstructions to", os.path.join(output_dir, "pred_sample.png"))
+        print("indices shape:", indices.shape)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkpoint", type=str, required=True)
+    parser.add_argument("--data_root", type=str, required=True)
+    parser.add_argument("--output_dir", type=str, default="outputs/pred")
+    parser.add_argument("--batch_size", type=int, default=8)
+    parser.add_argument("--max_slices", type=int, default=40)
+    args = parser.parse_args()
+    visualise(args.checkpoint, args.data_root, args.output_dir, args.batch_size, args.max_slices)
\ No newline at end of file

From 1e4401ab92b1c9f94830ceb229b0b13dd4b7134f Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sat, 25 Oct 2025 17:40:58 +1000
Subject: [PATCH 12/15] fixed bugs for train.py and modules.py

fixed some bugs that was found in the train.py file and module.py file preventing me from training the model
---
 .DS_Store                                     | Bin 0 -> 6148 bytes
 recognition/.DS_Store                         | Bin 0 -> 6148 bytes
 .../__pycache__/modules.cpython-310.pyc       | Bin 3446 -> 3413 bytes
 .../__pycache__/utils.cpython-310.pyc         | Bin 0 -> 1862 bytes
 recognition/GANmodel_47508042/modules.py      |   4 +-
 recognition/GANmodel_47508042/train.py        |  46 +++++++++---------
 6 files changed, 25 insertions(+), 25 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 recognition/.DS_Store
 create mode 100644 recognition/GANmodel_47508042/__pycache__/utils.cpython-310.pyc

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..7a52f2ed3942755e1e79a79424d412d3ca281bb5
GIT binary patch
literal 6148
zcmeHKJ5EC}5S)b+k<z53^cA>)6@?RU0YnlZq$p2HpnnzT;%Ll%3Zh54&_uJ+dhGR%
zEl=_GEdX16ZXbaqfH~a}Up`FD_uVIUR}mx9dBz(Kc*h5Qm}LJQaP9&}?64u{H~+9b
zZT7Fju=f<16p#W^Knh3!DR3nPs<6%%S2|C}NC7EuI|}&sq0t?C;g}eo4i3=*5N8aB
zaUQ({v3Y>l3&%u8XqHrBQmtAHOFHAN@_ONzm~>b*A67S8bto3M^ZXX+u%4(<3P^!-
z1@3dX^!ooqztI1mleCfoQsAZ(u-W=~z2cLqwoV@BwYJe;=$`XUcjG)L9HJZ(qa1VL
f<@h0zGOziZ`@L{X3_9aMC+cUwb&*Md|5o4!2U->v

literal 0
HcmV?d00001

diff --git a/recognition/.DS_Store b/recognition/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..e93a6e752479aeb781a97dad9122328f04ad3430
GIT binary patch
literal 6148
zcmeHKyG{c!5S)b+k!V6k=}!O@1mzJ0(b4b$APC)|D-iuvd>5a_?4vmyR1r-yE3L;~
z@7VGbx3>Un^SQeKRsfcCM|}A(H{W-k*-=G|Naq;?c6dXNC#+}LzXzOqihJDR0q+z3
zHLh@u8~PfTyN}oYWf*!-mq`IBAO)m=6p#XYC{V?8d9ueDqDlcNaF`1C_o2}pyTUOs
zJ{=sQ1t2aM4&yv}31agAu`3)C8KGHHiAl9;F)Znfx611Z$Hb(=s`;?G*{VaaxSi*>
zNQZTa8l`{~m@06b%azyvJNh5}|CFSa6p#W3rGPEAkJ}BORJC>XIIp#h{!I6rZ@L@j
pLE#YPm>A`l3oplKk(7DO=iKiK$HbsB9(1C923!}J6!>oiegMzd77YLZ

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/__pycache__/modules.cpython-310.pyc b/recognition/GANmodel_47508042/__pycache__/modules.cpython-310.pyc
index 04d604bdf628dc43751046950cd790521b6a56bd..6a7957bea286744f0d2041155b8a70856b474aa2 100644
GIT binary patch
delta 279
zcmew+bybQtpO=@50SMOB{mE$C$h(ido-K=gAyX}T4f_J78m274g^XY}LkeRGa|%le
z(?XU7j0+iR*-L~L2m{rKEM%x*1ghtN@M{=BB0xT84QCBQmS_!!2!l97EmsX=4SNlv
z1OrGG$Y-x%1)9#7C78k}3DggynV>ZDWG@bXVX<561*t{3r6sAixRUepN;1<+C$Hg1
zVPh@MNGwR*Y|i<XiQ5<G>LNc7;XhfQN0iZPvMW!Ij1N!%gp1jL1P22jqX2smh_A_A
lWIg#UkBO`+kaLU8H$SB`C$)$f$SG0*5t<;vXR;ly1pxn3Me+au

delta 292
zcmcaA^-YR5pO=@50SMTP-)D4e<lV<!FPJ5?kg1lvhJ6834O5ozLPju~A%!u8IfW&K
zX(7u3k%bJk>?NWL#DHqV7c$f^0@ZUs_%)0m5g?zlhO>qtOQMEDgh8C4maB%bhP{SS
zf&nB8<g?eX0!?Sk5>8>11nLLUOi-G6vKNQHu;eZFg4Cki(vs9DuH^i@lEn1P$!j=L
z)VWe~lTuSsGV{`lZ?TuBW~OJ96yIVk&PXgsy#-d7nO>S-TD)0|^DUF2KhRr60U#m}
zNNBPb34++tKq88{Dn7NyXR-=U52N4YjXc5}ejpXxMOKr~@R%^VPiEwm21>~CS^xlG
CvQP^E

diff --git a/recognition/GANmodel_47508042/__pycache__/utils.cpython-310.pyc b/recognition/GANmodel_47508042/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05a7e294150d8951b9a885b2d23a4f2bf7bb7b0f
GIT binary patch
literal 1862
zcmZ`)OOG5i5Vrd<-P1e!NE8r@a%cgE3=BJ)RU)E*fILu^151<zMQMmyPTMonn|{T1
zXJ=PEr{o$5ao{|A<S+TkX>M@gzyYZ0+06q9w_LW%<?`26pY3vWH6T##{`tq`Czp`l
zaPWGuVelnXbq@q55#f|u8I5S$T9MVZcJ4$jUCwnP4|I0s=iMj(ox|PdBwFDs+~fXp
z8ufUW2cTKy);{U?j_(AuPBXPt9R<50tAq?kb&=?_EY$T-v8N(Tb2b)g5GG|_)mnu6
z`(J+pBPkdRMrFo@R9nFU0Fu2vHE$^`>qOU*WwA>0G-EQ=M+wFG(}H~m>Mf}1JP1t=
zXw%|<VF6|W$n3rEz?m<msnT)zxNjM&RL0NQW5H9YV9u$Sp8QIr2M+$)AAYX@$MB$5
zIxU8`%flio8CS!*Olu*F8wJabRH{DS+1|N2lp-m|MT&npymMnOFS*F#E1z85zP5d3
zXLuG66Np09QpB)f520Eh&QsZiW`Xz<6lcYUP6ulHQ-4E86HO1Sx!qVN^ckh3AqNhp
zn`Gu_x3L@NnKiR@=fG=hZgHDCjeUWPEbhLrf3#-qtfT$LenxMThr2Vc=`@hmk+n$<
zx(#W(O)?Ko$b995@DBGdXs;~hJ?@|2elOR|S9$lPCOGv%|JO@v0bW+#Tyy5-$p^YK
zUppa`0Q&XD;yu2K2td2hxVVO|K?2v0p9Ue6edG`e$1>&NVX7x#5tcF?r;w0v7-A-h
zC1V5+D+Z|zFO5KIuuF^Z5!1<}ztwu0#vfh}HRPm3qnm^9)*##+g!lVs_`~+#^263l
zBE1%vs|Ds`foBNl;*HX=N{@wc#*!T&f0CS4k^k)}7-N^C(E`^-YxiEE0*WktS$eQ}
zmG1S=wfUErdWrsx2lOadE{v-ttP;k~)56$Qrj4)aM^#p8Wn9UMu`r!9SCjJ4*hy6z
zPd%xH06<+ObgWaI0X7DFH$9z>Cpym9QCVxSg9rk6<0e_DMBg`^X^bI^+-VH)TcV(a
zp*M|<cHl%PL(}$TECrI&tf8YAV;o~P)<LH(g4l2a8qkZhN8h98;X`?W`g9FG*$0CJ
zgLzhv{a9O`{|udm%n5LjLbXoF%xdTxV|$E@hf}a*f6M4gGq<rCcgg5k2TsFT-#hNY
z=|JYfnRsE({QIO>ae!M#pHg5PUT8D_0V(JqX`H#&v`l}pseRp@2aSU#4Y=nXKWM3N
z>-5UX1uNQnD`bf*l>$Dt#M%mPC{^b|h0~A~JZ$4x79o=Y33hp~J9v#<OBS~D8ZV>q
z`xkv01)OOXw+TK~1K(CmhYQV;iNpvSx2W^#NWKew`8FyX1$U$Ael<-*h1Zbju&NRT
zH|_}TEp4o#G7iG-cMY8y?-W_&Oyi=0#7k&QM<t~cN?t;bcA8&Cv16$EZ{~ycZ)4o^
zeXv!CW5d~?4rICqpVhWLwf^Z@kn?LW-KP?trv94o;+U679JiD=t}bOVG3Rook=j}M
z2%Zk?na;A6@4zzo5sGaP(Ykuvz93t<&@xSwL^8<%3Zzj>uy)7SK;xAzTh98Q!R1_M
W;&VKh?OWjx-}M1=TdlzEUHBK;<=a^R

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index 4aea23d59..4e844e301 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -42,7 +42,7 @@ def __init__(self, num_embeddings=512, embedding_dim=64, beta=0.25):
         nn.init.uniform_(self.embedding.weight, -1.0 / self.num_embeddings, 1.0 / self.num_embeddings)
 
     def forward(self, z):
-        z_perm = z.permute(0, 2, 3, 1).contagious()
+        z_perm = z.permute(0, 2, 3, 1).contiguous()
         flat_z = z_perm.view(-1, self.embedding_dim)
 
         # compute distances
@@ -57,7 +57,7 @@ def forward(self, z):
         encodings.scatter_(1, encoding_indices, 1)
 
         # quantized
-        quantized = torch.matmul(encodings, self.embeddings.weights)
+        quantized = torch.matmul(encodings, self.embedding.weight)
         quantized = quantized.view(z_perm.shape)
         quantized = quantized.permute(0, 3, 1, 2).contiguous()
 
diff --git a/recognition/GANmodel_47508042/train.py b/recognition/GANmodel_47508042/train.py
index ab0e79499..7bb2f06ef 100644
--- a/recognition/GANmodel_47508042/train.py
+++ b/recognition/GANmodel_47508042/train.py
@@ -11,7 +11,7 @@
 from utils import ensure_dir, save_pair_grid, batch_ssim
 
 def train_loop(args):
-    device = torch.device('cuda' if torch.cude.is_available() else 'cpu')
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     print("device:", device)
 
     ds = HipMRIDataset(args.data_root, image_size=args.image_size, max_slices_per_volume=args.max_slices, recursive=True)
@@ -23,10 +23,10 @@ def train_loop(args):
     train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
     val_loader = DataLoader(val_set, batch_size=args.batch_size, shuffle=False, num_workers=args.workers)
 
-    model = VQVAE(in_ch=1, hidden=args.hidden, z_channels=args.z_channels, num_embeddings=args.num_embeddings, beta=args.beta).to(device)
-    optimiser = optim.Adam(model.parameters90, lr=args.lr)
+    model = VQVAE(in_ch=1, hidden=args.hidden, z_channels=args.z_ch, num_embeddings=args.num_embeddings, beta=args.beta).to(device)
+    optimiser = optim.Adam(model.parameters(), lr=args.lr)
 
-    '''ensure_dir(args.output_dir)'''
+    ensure_dir(args.output_dir)
     best_ssim = 0.0
 
     for epoch in range(1, args.epochs + 1):
@@ -86,22 +86,22 @@ def train_loop(args):
 
     print("Training complete. Best SSIM:", best_ssim)
 
-    if __name__ == "__main__":
-        parser = argparse.ArgumentParser()
-        parser.add_argument("--data_root", type=str, required=True)
-        parser.add_argument("--output_dir", type=str, default="outputs")
-        parser.add_argument("--image_size", type=int, default=256)
-        parser.add_argument("--epochs", type=int, default=40)
-        parser.add_argument("--batch_size", type=int, default=8)
-        parser.add_argument("--lr", type=float, default=2e-4)
-        parser.add_argument("--z_ch", type=int, default=64)
-        parser.add_argument("--hidden", type=int, default=128)
-        parser.add_argument("--num_embeddings", type=int, default=512)
-        parser.add_argument("--beta", type=float, default=0.25)
-        parser.add_argument("--max_slices", type=int, default=40)
-        parser.add_argument("--val_frac", type=float, default=0.10)
-        parser.add_argument("--workers", type=int, default=2)
-        parser.add_argument("--save_every", type=int, default=10)
-        args = parser.parse_args()
-        ensure_dir(args.output_dir)
-        train_loop(args)
\ No newline at end of file
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_root", type=str, required=True)
+    parser.add_argument("--output_dir", type=str, default="outputs")
+    parser.add_argument("--image_size", type=int, default=256)
+    parser.add_argument("--epochs", type=int, default=40)
+    parser.add_argument("--batch_size", type=int, default=8)
+    parser.add_argument("--lr", type=float, default=2e-4)
+    parser.add_argument("--z_ch", type=int, default=64)
+    parser.add_argument("--hidden", type=int, default=128)
+    parser.add_argument("--num_embeddings", type=int, default=512)
+    parser.add_argument("--beta", type=float, default=0.25)
+    parser.add_argument("--max_slices", type=int, default=40)
+    parser.add_argument("--val_frac", type=float, default=0.10)
+    parser.add_argument("--workers", type=int, default=2)
+    parser.add_argument("--save_every", type=int, default=10)
+    args = parser.parse_args()
+    ensure_dir(args.output_dir)
+    train_loop(args)
\ No newline at end of file

From 6ff96c4a9d2e1a0b45f3dbf4a78c0971713dc4b4 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Sun, 26 Oct 2025 12:07:18 +1000
Subject: [PATCH 13/15] updated certain files

fixed some issues with the utils, modules, dataset and predict.py files. got the code working which is good
---
 .idea/misc.xml                                   |   3 +++
 .../__pycache__/dataset.cpython-312.pyc          | Bin 0 -> 4199 bytes
 .../__pycache__/modules.cpython-312.pyc          | Bin 0 -> 6384 bytes
 .../__pycache__/utils.cpython-312.pyc            | Bin 0 -> 3178 bytes
 recognition/GANmodel_47508042/predict.py         |   6 +++---
 5 files changed, 6 insertions(+), 3 deletions(-)
 create mode 100644 recognition/GANmodel_47508042/__pycache__/dataset.cpython-312.pyc
 create mode 100644 recognition/GANmodel_47508042/__pycache__/modules.cpython-312.pyc
 create mode 100644 recognition/GANmodel_47508042/__pycache__/utils.cpython-312.pyc

diff --git a/.idea/misc.xml b/.idea/misc.xml
index dc9ea4906..9de286525 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10" />
+  </component>
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10" project-jdk-type="Python SDK" />
 </project>
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/__pycache__/dataset.cpython-312.pyc b/recognition/GANmodel_47508042/__pycache__/dataset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fec3a0cd5a767a4cc8148d9685959a9354d2fe4f
GIT binary patch
literal 4199
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

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/__pycache__/modules.cpython-312.pyc b/recognition/GANmodel_47508042/__pycache__/modules.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e5a5bd1cfcb350f645c9b1a423ae9bd5ff549da
GIT binary patch
literal 6384
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
Zv=~@`dFbwp&`#Q$I*BpnD_EeP>wj)LwZH%X

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/__pycache__/utils.cpython-312.pyc b/recognition/GANmodel_47508042/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc194eb14f189a3974f005b977c8eb0339687317
GIT binary patch
literal 3178
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

literal 0
HcmV?d00001

diff --git a/recognition/GANmodel_47508042/predict.py b/recognition/GANmodel_47508042/predict.py
index 4039c1607..d60c50f6e 100644
--- a/recognition/GANmodel_47508042/predict.py
+++ b/recognition/GANmodel_47508042/predict.py
@@ -7,9 +7,9 @@
 from utils import ensure_dir, save_pair_grid
 
 def visualise(checkpoint, data_root, output_dir, batch_size=8, max_slices=40):
-    device = torch.device('cude' if torch.cude.is_available() else 'cpu')
-    checkpoint = torch.load(checkpoint, map_location=device)
-    model = VQVAE(in_ch=1, hidden=128, z_ch=64, num_embeddings=512, beta=0.25).to(device)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    checkpoint = torch.load(checkpoint, map_location=device, weights_only=True)
+    model = VQVAE(in_ch=1, hidden=128, z_channels=64, num_embeddings=512, beta=0.25).to(device)
     model.load_state_dict(checkpoint['model_state'])
     model.eval()
 

From 89f63f83c9f660d5a302f1d9364807d7aa4a912e Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Tue, 28 Oct 2025 14:23:57 +1000
Subject: [PATCH 14/15] final updates each file

commented each file and finished up the readme. double checked the code whether it works and it does so this should be the final edit.
---
 recognition/GANmodel_47508042/README.md       |  28 ++++++----
 .../__pycache__/dataset.cpython-312.pyc       | Bin 4199 -> 4553 bytes
 .../__pycache__/modules.cpython-312.pyc       | Bin 6384 -> 6880 bytes
 .../__pycache__/utils.cpython-312.pyc         | Bin 3178 -> 3085 bytes
 recognition/GANmodel_47508042/dataset.py      |  22 ++++++--
 recognition/GANmodel_47508042/modules.py      |  49 +++++++++++++-----
 recognition/GANmodel_47508042/predict.py      |   4 ++
 recognition/GANmodel_47508042/train.py        |  11 ++--
 recognition/GANmodel_47508042/utils.py        |   5 --
 9 files changed, 86 insertions(+), 33 deletions(-)

diff --git a/recognition/GANmodel_47508042/README.md b/recognition/GANmodel_47508042/README.md
index f5d3e43b3..23e5174c9 100644
--- a/recognition/GANmodel_47508042/README.md
+++ b/recognition/GANmodel_47508042/README.md
@@ -9,15 +9,25 @@ reasonably clear images and reach SSIM > 0.6 on testing.
  - 'modules.py' - 'HipMRIDataset' loader
  - 'predict.py' - load best model and produce reconstructions
  - 'train.py' -  training loop, validation, checkpointing, plots
+ - 'utils.py' - helper functions for training and evaluation
+ - 'readme.md' - documentation
 
-## Requirements
-- Python 3.8+
-- PyTorch
-- torchvision
-- matplotlib
-- scikit-image
-- numpy
+## Install:
+```bash
+pip install torch torchvision matplotlib scikit-image numpy nibabel tqdm
+```
+
+## Training
+To train the model, run:
+```bash
+python3 train.py --data_root "/Users/justin/Downloads/HipMRIDataset"
+```
 
-Install:
+## Prediction
+To generate reconstructions using the best model, run:
 ```bash
-pip install torch torchvision matplotlib scikit-image numpy
\ No newline at end of file
+python3 predict.py --checkpoint outputs/best_checkpoint.pth --data_root "/Users/justin/Downloads/HipMRIDataset"
+```
+
+## Author
+Justin Teng (47508042)
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/__pycache__/dataset.cpython-312.pyc b/recognition/GANmodel_47508042/__pycache__/dataset.cpython-312.pyc
index fec3a0cd5a767a4cc8148d9685959a9354d2fe4f..bc811c4599e2cf85607ef23cffed45ab1c344ce5 100644
GIT binary patch
delta 678
zcmY*V&ubGw7~M&-$tK<WXmYH@57JsAC~6R)gd8+tqqTx4VnE7fXEvR(yAx)2i^;_v
zB32Q9FbDqwucEp5FNh!>1WPW02)$~fCoi4dnur7QhVR?=y|?e%gZJg!hio>Z$aCkS
zLhtG?a&PaSkkw0tC@qAQRt%$79H(%6fLaNh7$_|js}hqqDKXWHRkTrdg?6vqXf_Pr
z@QB}UXFwi&Sb@bj*v!Dx?Lf5w8?+0O3tP+%9O8k+nFDK0>t+)yYRiVP;9~G>YK8;;
z262G8K7+FjppMZY-l<6a&7VO6>BDXHQQYhsQ7bexnQar(2gA1i6Qyn_1)MP-Fy)fM
zcn^*np;geHbf~na7Rb*5_vjX>Om#&j{qAT*?#25gVO#m3DaFN|<Zhw3qwdb+pVc4N
zzl*Qw+o&kcXI`)NuS_R7@dNI9k-g7+!v;5S+JpnM!c1Y%Fto{;Cm;FSe-|?q5PO+=
zp%z+~BI{q8QYa0pGn*(K$MFX-EK$7DPojkQtUtV}_Rmd6JH(HCCq7^t)*YG6m21W1
z-aqd0lhfax_Ab>cXryAl*ClI$WyggJq4UQ{=<<^2=Dr|JtmGF`qtyC3W~SK8pP8SN
zjDhkq7E`rxa!#%8FVCv;`^OS$d8`-3FmIKwO9l^D$d@FHw3@?kV3Rt(B}*i)w<v0b
RBeSarm7ZVzt%PsHKLGQ6z|{Z%

delta 325
zcmX@9{9J+WG%qg~0}yQJ{*&>Ub0Xg+Yc(KmIzuW$6k`fQ6jKUY3R4SX6mtr53qur3
z3JZ{AO<@I+Y?X|f?6-J5G7EfzJY5n?5{pwyHYYQ-urP9Ne!<$w%;-1y3g-@4kZHx|
zfJ6hs4MCL-wi^OM9jrIF`TOm<?Cwln%@xilFqxTqJy7*OZaY2`kZM7&>O1^Gn|*k)
z7&#eI7+RT9faK);yt<6cli%{Ti?H~mTlE+`>Z^3M(`3BGno?3(kUDuk-)BB^kO5~P
z)+wn?KE!{Wk$v(k0hP(e1@tAvfZ{C-pP8gtjXzoOu*!atVPsYQ%*H=iSTIf54=7or
s2_n>i#4Qe+-29Z%oK(A_5FnQkh>Mjc&k>a2w__BZ;Qo~XNP$%Y0LK(pdjJ3c

diff --git a/recognition/GANmodel_47508042/__pycache__/modules.cpython-312.pyc b/recognition/GANmodel_47508042/__pycache__/modules.cpython-312.pyc
index 4e5a5bd1cfcb350f645c9b1a423ae9bd5ff549da..495e1efff8140d6f7865f83632367f39b99ca176 100644
GIT binary patch
delta 1271
zcmbW0&ubGw6vt<_yG_!XAKiqcNn1O#3Qeumwp5`-wAw1UC_xBq5JHmOq$|yCo!$5&
zm-bLFJyn@QK`$N!L6H0hdJ;i;?!^`g-lSq$6g>E5H%(RW2OZcq@9oUIdGq1>c1O0x
zeeb;9HUwkt3eqM5uYAYw(jbHn(K=F58Y?I*C^+4sh*ea;im>8Ii%QE1N=sFAAE#Sy
zqPVo_n$h!yqSDHRHUcAWloqLKnyN{xd6j7TV%Z{EDO*&DWsrrerRo-;D&GTM*3t~!
zIVbW$P%VWM0`{<HEpN`nab?tA<9Q1Py_cm5S<IR|Gd0S^dHV*{xxTrP6~yy_Af);t
zgIPwqZWIWy7h)fFvG?MMz@{scQH*>hL)&4U#@IJ;EX22dT|u7(L2~c4x}~=LkjN&b
zz9Zn6RvjFZc108--Lz;qZ#96}C<@dl{Tl{CY!-WK&m~E~J?y1xW9k2pC{77YBymhn
z!2{z0?SN?$S4;tBLTDH!8Us`DH_9Gva30_*UED;t>E@;vvF%8ZeQ<lCQHaf7p?LsW
zSY+SbM}X!}sd>ww$#Pb=v<hfx*sk6AOB%mztpKzKD&=Y*spRR@)Qr6`?}!JAg3(&j
zJYfNk)|T6+r18pF6T=@Rlu9~jn>%Z-1Gg}av0k}5FbOHm9o&$T9ApXk3HH@?<Qv$3
z9M(SaI}zHrNPF2<B-DQv0?N%Wd?pv-p|D(15%0@=%nBU=l9Woqdn?x*H1^|32|90q
z_gqfXHN8k0%`imn+Ca&j1ENDDt1ILuVPH~w8@i5ho^^&ljf1X6ny>#0rzUaUlB_)v
z#Zh)LGSP2q$ZHpPprG6Q`Io@hE$9!j<;c}o55$yHqq9wKj(eP4Pc#GWZ?cl4iG81o
zb#y+RmT^}#x2COXbp&pGAb1#qTOT}wM;_(Ywa2gyZas%(9IswpOROgL;6U6~@(;rD
BNfiJ9

delta 777
zcmaE0`oWOzG%qg~0}yQJ{*!T!XCogEqp2E@+s-hZA(bJDF@+(DDTTR%A&oJGv4t~=
zIfbc(A&RAgp@K1rHJCw@<rceZUUGg)YSHFNi~&q+Y(TBW6_cwt6ee@9%wt~3=r{Qe
zi#eYFQ1~;5XkfU(FFaY9Rf&;pvKy-kdl5HKut<7x6{|5nFOd18h2bj`2P@Y%5yr^}
zS(Qk1ic2cQDUoc_OpGFvOF1sE7D)n4om|Z+7cC8BRPjTV=%wWsl_wUZ$b+nx0TJRL
zLKZ|QfCyC}QOpP=9E!w1e03Nh43dC5l@sVxF~-S1IhAZl3N`+))Z~)<qQKI`ypqf+
zVCeO5sW34rZ{En`$ja!qSzRcGQ5)=FaWsW6hwFfx@d)TZV2BC|P2M0pi;-uuw}?L@
zKgdhZffxub*cT~GUMVUoss!W|^8pEP__DL6Gkz12oBTjj$(STpvxWtRIl69c67yqZ
z^qqWB{GB{Fcr}@eVu5BC#es-;Afd@#BnV<lP3DudQUv>h7pxWL`VgROu^o^Ax}HyH
za<-(KlpII{I65NWtVj?`Ve)B7SrH!~6A|pJtXALnSSB+{&355ol<r9C&+N?n!T@A`
rk>N$~fy^&*8jOY$lBQ=)1j+-MUqTpp7&SYb`aL^6zXCOAg5w<kfWElp

diff --git a/recognition/GANmodel_47508042/__pycache__/utils.cpython-312.pyc b/recognition/GANmodel_47508042/__pycache__/utils.cpython-312.pyc
index bc194eb14f189a3974f005b977c8eb0339687317..578abb109b9f2e59dbafeacbfff7da32b3791685 100644
GIT binary patch
delta 156
zcmaDQ(JR4wnwOW00SMN+Fl6RU<dyXE0CJ`?q%fo~<}gG-XvQc;FrO)xIf{i5BE}lU
z1{7n;VbA4=;slB@w=hI;rLd*2v@k|-r?3KfJe7=^>>Cd<GBUDnKFoNXg^_FXY&LBc
lM!Ctyxt=ldPTtO4E()@Y5r~VGfy4)9pxWCEoRhtH6aY$JA*KKT

delta 250
zcmeB`cqPGmnwOW00SGp9|H(Kskyo<b2gsSukirnfkiwY4l*1Us2&S2$n7}l1E=v?E
zBSelZiXAA%oWqgJ8N~$@V`*WC;!a^tVQpcI;z?lx@^~wmG&!o=xk^hibBgr}D!DvT
za|%+66w*rbl1no4^NOt$iWAFH6*6-Z(^HFe6q560atlgJQWb)OJ$-@PqSQnnCoMlG
zCAFwnk85KIBO@cv<}$|XER6h{{n)fw7?meiaXsVWyTu+KpOT*(A3r&fyIjT-=m$n1
bF4h7PADDrfJ~A;gvV7)ZVC0(omRkV;@YO;d

diff --git a/recognition/GANmodel_47508042/dataset.py b/recognition/GANmodel_47508042/dataset.py
index 47c65111f..2d20488e4 100644
--- a/recognition/GANmodel_47508042/dataset.py
+++ b/recognition/GANmodel_47508042/dataset.py
@@ -6,11 +6,14 @@
 from torchvision import transforms
 
 class HipMRIDataset(Dataset):
+    """
+    dataset for loading 3D hip MRI volumes from NIfTI files and slicing them into 2D images.
+    """
     def __init__(self, root_dir, image_size=256, transform=None, max_slices_per_volume=None, recursive=True):
-        self.root_dir = root_dir
-        self.image_size = image_size
-        self.max_slices = max_slices_per_volume
-        self.recursive = recursive
+        self.root_dir = root_dir  # root directory containing NIfTI files
+        self.image_size = image_size  # size to resize images to
+        self.max_slices = max_slices_per_volume  # max number of slices to use per volume
+        self.recursive = recursive  # whether to search subdirectories
 
         # finding files
         self.files = self.collect_files()
@@ -36,23 +39,34 @@ def __init__(self, root_dir, image_size=256, transform=None, max_slices_per_volu
                 self.index_map.append((f_idx, si))
 
     def collect_files(self):
+        """
+        collect all NIfTI files in the root directory (and subdirectories if recursive)
+        """
         exists = ('.nii', '.nii.gz')
         files = []
         if self.recursive:
+            # walk through subdirectories
             for root, _, filenames in os.walk(self.root_dir):
                 for fn in filenames:
                     if fn.lower().endswith(exists):
                         files.append(os.path.join(root, fn))
         else:
+            # only current directory
             for fn in os.listdir(self.root_dir):
                 if fn.lower().endswith(exists):
                     files.append(os.path.join(self.root_dir, fn))
         return sorted(files)
 
     def __len__(self):
+        """
+        returns the total number of 2D slices across all volumes
+        """
         return len(self.index_map)
 
     def __getitem__(self, index):
+        """
+        get the 2D slice at the given index
+        """
         file_index, slice_index = self.index_map[index]
         path = self.files[file_index]
         vol = nib.load(path).get_fdata()
diff --git a/recognition/GANmodel_47508042/modules.py b/recognition/GANmodel_47508042/modules.py
index 4e844e301..dfef14a85 100644
--- a/recognition/GANmodel_47508042/modules.py
+++ b/recognition/GANmodel_47508042/modules.py
@@ -3,45 +3,63 @@
 import torch.nn.functional as F
 
 class Encoder(nn.Module):
+    """
+    compresses the input image to latent representation
+    """
     def __init__(self, in_ch=1, hidden=128, z_channels=64):
         super().__init__()
         self.enc = nn.Sequential(
-            nn.Conv2d(in_ch, hidden//2, 4, 2, 1),
+            nn.Conv2d(in_ch, hidden//2, 4, 2, 1),  # downsample 1
             nn.ReLU(True),
-            nn.Conv2d(hidden//2, hidden, 4, 2, 1),
+            nn.Conv2d(hidden//2, hidden, 4, 2, 1),  # downsample 2
             nn.ReLU(True),
-            nn.Conv2d(hidden, z_channels, 3, 1, 1),
+            nn.Conv2d(hidden, z_channels, 3, 1, 1),  # project to latent space
         )
 
     def forward(self, x):
-        return self.enc(x)
+        """
+        forward pass through the encoder
+        """
+        return self.enc(x)  # returns latent representation z_e
 
 class Decoder(nn.Module):
+    """
+    reconstructs the image from latent representation
+    """
     def __init__(self, out_ch=1, hidden=128, z_channels=64):
         super().__init__()
         self.dec = nn.Sequential(
             nn.Conv2d(z_channels, hidden, 3, 1, 1),
             nn.ReLU(True),
-            nn.ConvTranspose2d(hidden, hidden//2, 4, 2, 1),
+            nn.ConvTranspose2d(hidden, hidden//2, 4, 2, 1),  # upsample 1
             nn.ReLU(True),
-            nn.ConvTranspose2d(hidden//2, out_ch, 4, 2, 1),
-            nn.Sigmoid()
+            nn.ConvTranspose2d(hidden//2, out_ch, 4, 2, 1),  # upsample 2
+            nn.Sigmoid()  # output in [0,1]
         )
 
     def forward(self, z):
-        return self.dec(z)
+        """
+        forward pass through the decoder
+        """
+        return self.dec(z)  # returns reconstructed image
 
 class VectorQuantizer(nn.Module):
+    """
+    Vector Quantization layer for VQ-VAE
+    """
     def __init__(self, num_embeddings=512, embedding_dim=64, beta=0.25):
         super().__init__()
-        self.num_embeddings = num_embeddings
-        self.embedding_dim = embedding_dim
-        self.beta = beta
+        self.num_embeddings = num_embeddings  # number of discrete embeddings
+        self.embedding_dim = embedding_dim  # dimension of each embedding
+        self.beta = beta  # commitment loss weight
 
         self.embedding = nn.Embedding(self.num_embeddings, self.embedding_dim)
         nn.init.uniform_(self.embedding.weight, -1.0 / self.num_embeddings, 1.0 / self.num_embeddings)
 
     def forward(self, z):
+        """
+        forward pass through the VQ layer
+        """
         z_perm = z.permute(0, 2, 3, 1).contiguous()
         flat_z = z_perm.view(-1, self.embedding_dim)
 
@@ -52,11 +70,12 @@ def forward(self, z):
             - 2 * torch.matmul(flat_z, self.embedding.weight.t())
         )
 
+        # encoding
         encoding_indices = torch.argmin(distances, dim=1).unsqueeze(1)
         encodings = torch.zeros(encoding_indices.size(0), self.num_embeddings, device=z.device)
         encodings.scatter_(1, encoding_indices, 1)
 
-        # quantized
+        # quantize and reshape
         quantized = torch.matmul(encodings, self.embedding.weight)
         quantized = quantized.view(z_perm.shape)
         quantized = quantized.permute(0, 3, 1, 2).contiguous()
@@ -74,6 +93,9 @@ def forward(self, z):
         return quantized, loss, encoding_indices
 
 class VQVAE(nn.Module):
+    """
+    VQ-VAE model combining encoder, vector quantizer, and decoder
+    """
     def __init__(self, in_ch=1, hidden=128, z_channels=64, num_embeddings=512, embedding_dim=64, beta=0.25):
         super().__init__()
         assert z_channels == embedding_dim
@@ -82,6 +104,9 @@ def __init__(self, in_ch=1, hidden=128, z_channels=64, num_embeddings=512, embed
         self.decoder = Decoder(in_ch, hidden, z_channels)
 
     def forward(self, x):
+        """
+        forward pass through the VQ-VAE
+        """
         z_e = self.encoder(x)
         quantized, vq_loss, indices = self.vq(z_e)
         x_recon = self.decoder(quantized)
diff --git a/recognition/GANmodel_47508042/predict.py b/recognition/GANmodel_47508042/predict.py
index d60c50f6e..a318f9965 100644
--- a/recognition/GANmodel_47508042/predict.py
+++ b/recognition/GANmodel_47508042/predict.py
@@ -7,6 +7,9 @@
 from utils import ensure_dir, save_pair_grid
 
 def visualise(checkpoint, data_root, output_dir, batch_size=8, max_slices=40):
+    """
+    Visualise reconstructions from a trained VQ-VAE model
+    """
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     checkpoint = torch.load(checkpoint, map_location=device, weights_only=True)
     model = VQVAE(in_ch=1, hidden=128, z_channels=64, num_embeddings=512, beta=0.25).to(device)
@@ -33,4 +36,5 @@ def visualise(checkpoint, data_root, output_dir, batch_size=8, max_slices=40):
     parser.add_argument("--batch_size", type=int, default=8)
     parser.add_argument("--max_slices", type=int, default=40)
     args = parser.parse_args()
+    # run visualisation
     visualise(args.checkpoint, args.data_root, args.output_dir, args.batch_size, args.max_slices)
\ No newline at end of file
diff --git a/recognition/GANmodel_47508042/train.py b/recognition/GANmodel_47508042/train.py
index 7bb2f06ef..e4d89fd5f 100644
--- a/recognition/GANmodel_47508042/train.py
+++ b/recognition/GANmodel_47508042/train.py
@@ -11,24 +11,29 @@
 from utils import ensure_dir, save_pair_grid, batch_ssim
 
 def train_loop(args):
+    """
+    main training loop for VQ-VAE on hip MRI dataset
+    """
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     print("device:", device)
 
     ds = HipMRIDataset(args.data_root, image_size=args.image_size, max_slices_per_volume=args.max_slices, recursive=True)
-    # split training and testing 90/10
+    # split training and testing
     n_val = max(1, int(len(ds) * args.val_frac))
     n_train = len(ds) - n_val
     train_set, val_set = random_split(ds, [n_train, n_val])
 
+    # data loaders
     train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
     val_loader = DataLoader(val_set, batch_size=args.batch_size, shuffle=False, num_workers=args.workers)
-
     model = VQVAE(in_ch=1, hidden=args.hidden, z_channels=args.z_ch, num_embeddings=args.num_embeddings, beta=args.beta).to(device)
     optimiser = optim.Adam(model.parameters(), lr=args.lr)
 
+    # output directory
     ensure_dir(args.output_dir)
     best_ssim = 0.0
 
+    # training loop
     for epoch in range(1, args.epochs + 1):
         model.train()
         train_loss = 0.0
@@ -104,4 +109,4 @@ def train_loop(args):
     parser.add_argument("--save_every", type=int, default=10)
     args = parser.parse_args()
     ensure_dir(args.output_dir)
-    train_loop(args)
\ No newline at end of file
+    train_loop(args)
diff --git a/recognition/GANmodel_47508042/utils.py b/recognition/GANmodel_47508042/utils.py
index 0b4f944f9..519313a5d 100644
--- a/recognition/GANmodel_47508042/utils.py
+++ b/recognition/GANmodel_47508042/utils.py
@@ -1,8 +1,3 @@
-"""
-utils.py
-Helper functions: save images, compute SSIM, create folders.
-"""
-
 import os
 import torch
 import matplotlib.pyplot as plt

From 2591f7201ff893845b3bb118314aa2ecc1f55e61 Mon Sep 17 00:00:00 2001
From: justint3ng <justint3ng@gmail.com>
Date: Tue, 28 Oct 2025 16:20:10 +1000
Subject: [PATCH 15/15] readme update

updated my readme file to meet the marking criterias.
---
 recognition/GANmodel_47508042/README.md | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/recognition/GANmodel_47508042/README.md b/recognition/GANmodel_47508042/README.md
index 23e5174c9..e07e12ee6 100644
--- a/recognition/GANmodel_47508042/README.md
+++ b/recognition/GANmodel_47508042/README.md
@@ -1,8 +1,18 @@
 # Pattern Recognition - Generative Model using VQVAE
 
 ## Overview
-This project uses VQVAE to create a generative model of the HipMRI Study on Prostate Cancer. The goal is to produce
-reasonably clear images and reach SSIM > 0.6 on testing.
+This project implements a Vector Quantised Variational Autoencoder (VQVAE) to learna generative model from the HipMRI
+prostate cancer study dataset. THe model reconstructs 2D MRI slices using compressed discrete latent codes, effectively
+learning meaningful anatomical representation of prostate structures. The objective of this is to produce clear, realistic
+reconstructions of MRI slices with a SSIM > 0.6 on testing.
+
+## How it works
+VQVAE is a discrete latent variable model that combines that representational power of neural networks with the 
+compression efficiency of vector quantization. It consists of three main components:
+1. Encoder: A convolutional neural network that maps input MRI slices to a continuous latent space.
+2. Vector Quantizer: This module discretizes the continuous latent representations into a finite set of learned embedding vectors (codebook).
+3. Decoder: Another convolutional neural network that reconstructs the MRI slices from the quantized latent codes.
+The model is trained end-to-end using a combination of reconstruction loss (Mean Squared Error) and a commitment loss (VQ loss)
 
 ## Files
  - 'dataset.py' - Encoder, Decoder, VectorQuantizer, VQVAE model