Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text

CNN/CNN.py

@@ -0,0 +1,132 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import transforms, models
+import medmnist
+from medmnist import INFO
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+
+def main():
+    # 1. Setup and Hardware Configuration
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Training on: {device}")
+
+    # Set this to point to your secondary NVMe drive to prevent OS drive I/O bottlenecks
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data" 
+    os.makedirs(dataset_root, exist_ok=True)
+
+    data_flag = 'pneumoniamnist'
+    info = INFO[data_flag]
+    DataClass = getattr(medmnist, info['python_class'])
+
+    # 2. The Golden Preprocessing & Dynamic Augmentation
+    # We normalize to [-1, 1] using mean=0.5, std=0.5 so it matches your team's generator math
+    train_transform = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3), # ResNet expects 3 RGB channels
+        transforms.RandomHorizontalFlip(),           # Dynamic spatial augmentation
+        transforms.RandomRotation(10),               # Dynamic spatial augmentation
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) 
+    ])
+
+    val_transform = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3),
+        transforms.ToTensor(),                       # NO spatial augmentation for validation
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ])
+
+    # 3. Load Datasets
+    print("Fetching 224x224 dataset...")
+    train_dataset = DataClass(split='train', transform=train_transform, download=True, size=224, root=dataset_root)
+    val_dataset = DataClass(split='val', transform=val_transform, download=True, size=224, root=dataset_root)
+
+    # 4. DataLoaders
+    # Using batch size 32. num_workers=0 is the safest default for Windows to prevent multiprocessing crashes.
+    train_loader = DataLoader(dataset=train_dataset, batch_size=32, shuffle=True, num_workers=0)
+    val_loader = DataLoader(dataset=val_dataset, batch_size=32, shuffle=False, num_workers=0)
+
+    # 5. Initialize ResNet50
+    print("Loading ResNet50...")
+    model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
+    
+    # Modify the final layer for Binary Classification (Pneumonia vs Normal)
+    num_ftrs = model.fc.in_features
+    model.fc = nn.Linear(num_ftrs, 2)
+    model = model.to(device)
+
+    # 6. Loss and Optimizer
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=1e-4) # 1e-4 is a very stable learning rate for fine-tuning
+    num_epochs = 10
+
+    history_loss = []
+    history_acc = []
+    
+    # 7. The Training Loop
+    for epoch in range(num_epochs):
+        model.train()
+        running_loss = 0.0
+        correct = 0
+        total = 0
+        
+        # tqdm creates a nice progress bar in the terminal
+        loop = tqdm(train_loader, leave=True)
+        for images, labels in loop:
+            images, labels = images.to(device), labels.to(device).squeeze().long()
+            
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            
+            running_loss += loss.item()
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+            
+            loop.set_description(f"Epoch [{epoch+1}/{num_epochs}]")
+            loop.set_postfix(loss=loss.item(), acc=100.*correct/total)
+
+        # Calculate the average loss and accuracy for this epoch
+        epoch_loss = running_loss / len(train_loader)
+        epoch_acc = 100. * correct / total
+        
+        history_loss.append(epoch_loss)
+        history_acc.append(epoch_acc)
+
+    # 8. Save the Frozen Weights for your team
+    save_path = os.path.join(dataset_root, 'baseline_resnet50.pth')
+    torch.save(model.state_dict(), save_path)
+    print(f"\nTraining Complete! Baseline weights saved to: {save_path}")
+
+    # Create the Learning Curve Graph
+    fig, ax1 = plt.subplots(figsize=(10, 6))
+
+    # Plot Loss (Red Line)
+    color = 'tab:red'
+    ax1.set_xlabel('Epochs', fontweight='bold')
+    ax1.set_ylabel('Training Loss', color=color, fontweight='bold')
+    ax1.plot(range(1, num_epochs+1), history_loss, color=color, marker='o', label='Loss')
+    ax1.tick_params(axis='y', labelcolor=color)
+
+    # Plot Accuracy (Blue Line) on the same graph
+    ax2 = ax1.twinx()  
+    color = 'tab:blue'
+    ax2.set_ylabel('Training Accuracy (%)', color=color, fontweight='bold')
+    ax2.plot(range(1, num_epochs+1), history_acc, color=color, marker='s', label='Accuracy')
+    ax2.tick_params(axis='y', labelcolor=color)
+
+    plt.title('ResNet50 Training Curve', fontsize=14, fontweight='bold')
+    fig.tight_layout()
+    
+    # Save the image
+    graph_path = os.path.join(dataset_root, 'learning_curve.png')
+    plt.savefig(graph_path, dpi=300)
+    print(f"Learning Curve saved to: {graph_path}")
+
+if __name__ == '__main__':
+    main()

CNN/Evaluate.py

@@ -0,0 +1,110 @@
+import os
+import torch
+import torch.nn as nn
+from torchvision import transforms, models
+import medmnist
+from medmnist import INFO
+from torch.utils.data import DataLoader
+from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay, roc_curve, auc
+import matplotlib.pyplot as plt
+import numpy as np
+
+def main():
+    # 1. Hardware Setup (Hardware Agnostic)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Evaluating on: {device}")
+
+    # Streaming from the secondary NVMe
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data" 
+    
+    data_flag = 'pneumoniamnist'
+    info = INFO[data_flag]
+    DataClass = getattr(medmnist, info['python_class'])
+
+    # 2. Strict Validation Preprocessing
+    val_transform = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ])
+
+    # 3. Load the Validation Dataset
+    print("Loading Validation Data...")
+    val_dataset = DataClass(split='val', transform=val_transform, download=False, size=224, root=dataset_root)
+    val_loader = DataLoader(dataset=val_dataset, batch_size=32, shuffle=False, num_workers=0)
+
+    # 4. Reconstruct and Load the Model
+    print("Rebuilding ResNet50 Architecture...")
+    model = models.resnet50()
+    num_ftrs = model.fc.in_features
+    model.fc = nn.Linear(num_ftrs, 2) 
+    
+    #Put Model Path here
+    weights_path = r"C:\Users\Brian ooi\Documents\code\CVPR\CVPRAssignment\baseline_resnet50.pth"
+    model.load_state_dict(torch.load(weights_path, map_location=device, weights_only=True))
+    model = model.to(device)
+    model.eval() 
+
+    all_predictions = []
+    all_true_labels = []
+    all_probabilities = [] # Raw probabilities for the ROC curve
+
+    print("Running Inference...")
+    with torch.no_grad():
+        for images, labels in val_loader:
+            images = images.to(device)
+            labels = labels.to(device).squeeze().long()
+            
+            outputs = model(images)
+            
+            # Apply softmax to get percentages (0.0 to 1.0) instead of raw logits
+            probabilities = torch.softmax(outputs, dim=1)
+            _, predicted = torch.max(outputs.data, 1)
+            
+            all_predictions.extend(predicted.cpu().numpy())
+            all_true_labels.extend(labels.cpu().numpy())
+            # Save the probability specifically for the "Pneumonia (1)" class
+            all_probabilities.extend(probabilities[:, 1].cpu().numpy())
+
+    # 5. The Clinical Metrics (Sensitivity & Specificity)
+    cm = confusion_matrix(all_true_labels, all_predictions)
+    tn, fp, fn, tp = cm.ravel()
+    
+    sensitivity = tp / (tp + fn)
+    specificity = tn / (tn + fp)
+
+    print("\n" + "="*50)
+    print("CLINICAL PERFORMANCE METRICS")
+    print("="*50)
+    print(f"Sensitivity (Recall for Pneumonia): {sensitivity:.4f}")
+    print(f"Specificity (Recall for Normal):    {specificity:.4f}")
+    print("="*50)
+
+    # 6. Generate the ROC Curve
+    print("Generating ROC Curve Window...")
+    fpr, tpr, thresholds = roc_curve(all_true_labels, all_probabilities)
+    roc_auc = auc(fpr, tpr)
+
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (AUC = {roc_auc:.4f})')
+    ax.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--', label='Random Guessing')
+    ax.set_xlim([0.0, 1.0])
+    ax.set_ylim([0.0, 1.05])
+    ax.set_xlabel('False Positive Rate (1 - Specificity)', fontweight='bold')
+    ax.set_ylabel('True Positive Rate (Sensitivity)', fontweight='bold')
+    ax.set_title('Receiver Operating Characteristic (ROC) - Baseline ResNet50 (No Augmentation)', fontweight='bold')
+    ax.legend(loc="lower right")
+    
+    # Save the ROC curve to your NVMe
+    roc_path = os.path.join(dataset_root, 'roc_curve.png')
+    plt.savefig(roc_path, dpi=300)
+    # 7. Generate and Save the Confusion Matrix Grid
+    print("Generating Confusion Matrix Window...")
+    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Normal (0)", "Pneumonia (1)"])
+    disp.plot(cmap=plt.cm.Blues)
+    plt.title('Baseline ResNet50 (No Augmentation) - PneumoniaMNIST', fontweight='bold')
+    plt.savefig(os.path.join(dataset_root, 'baseline_confusion_matrix.png'), dpi=300)
+    plt.show()
+
+if __name__ == '__main__':
+    main()

CNN/Evaluate_All.py

@@ -0,0 +1,186 @@
+import os
+import torch
+import torch.nn as nn
+from torchvision import transforms, models
+import medmnist
+from medmnist import INFO
+from torch.utils.data import DataLoader
+from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay, roc_curve, auc
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ── CONFIG ────────────────────────────────────────────────────────────────────
+PROJECT_ROOT  = r"C:\Users\Brian ooi\Documents\code\CVPR\CVPRAssignment"
+RESULTS_ROOT  = os.path.join(PROJECT_ROOT, "results_run2")
+FIRST_RESULTS = os.path.join(PROJECT_ROOT, "results")
+
+MODELS = {
+    "Baseline": {
+        "weights": os.path.join(PROJECT_ROOT, "baseline_resnet50.pth"),
+        "label":   "Baseline ResNet50 (No Augmentation)",
+    },
+    "GAN": {
+        "weights": os.path.join(FIRST_RESULTS, "GAN-20260621T100120Z-3-001", "GAN", "hybrid_resnet50.pth"),
+        "label":   "Hybrid GAN ResNet50",
+    },
+    "EBM": {
+        "weights": os.path.join(FIRST_RESULTS, "EBM-20260621T100117Z-3-001", "EBM", "hybrid_ebm_resnet50.pth"),
+        "label":   "Hybrid EBM ResNet50",
+    },
+    "DiT": {
+        "weights": os.path.join(FIRST_RESULTS, "DiT-20260621T100114Z-3-001", "DiT", "hybrid_dit_resnet50.pth"),
+        "label":   "Hybrid DiT ResNet50",
+    },
+    "Diffusion": {
+        "weights": os.path.join(FIRST_RESULTS, "Diffusion-20260621T100111Z-3-001", "Diffusion", "hybrid_diffusion_resnet50.pth"),
+        "label":   "Hybrid Diffusion ResNet50",
+    },
+    "MaskGIT": {
+        "weights": os.path.join(FIRST_RESULTS, "MaskGiT-20260621T100123Z-3-001", "MaskGiT", "hybrid_maskgit_resnet50.pth"),
+        "label":   "Hybrid MaskGIT ResNet50",
+    },
+    "VAE": {
+        "weights": os.path.join(FIRST_RESULTS, "VAE-20260621T100129Z-3-001", "VAE", "hybrid_vae_resnet50.pth"),
+        "label":   "Hybrid VAE ResNet50",
+    },
+}
+# ─────────────────────────────────────────────────────────────────────────────
+
+def build_model(device):
+    model = models.resnet50()
+    model.fc = nn.Linear(model.fc.in_features, 2)
+    return model.to(device)
+
+def get_val_loader():
+    val_transform = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+    ])
+    info      = INFO["pneumoniamnist"]
+    DataClass = getattr(medmnist, info["python_class"])
+    val_ds    = DataClass(split="val", transform=val_transform,
+                          download=False, size=224, root=PROJECT_ROOT)
+    return DataLoader(val_ds, batch_size=32, shuffle=False, num_workers=0)
+
+def evaluate(model, val_loader, device):
+    model.eval()
+    preds, labels, probs = [], [], []
+    with torch.no_grad():
+        for imgs, lbls in val_loader:
+            imgs = imgs.to(device)
+            lbls = lbls.to(device).squeeze().long()
+            out  = model(imgs)
+            prob = torch.softmax(out, dim=1)
+            _, pred = torch.max(out, 1)
+            preds.extend(pred.cpu().numpy())
+            labels.extend(lbls.cpu().numpy())
+            probs.extend(prob[:, 1].cpu().numpy())
+    return np.array(preds), np.array(labels), np.array(probs)
+
+def save_results(name, label, preds, labels, probs, out_dir):
+    os.makedirs(out_dir, exist_ok=True)
+
+    # ── Confusion Matrix ──────────────────────────────────────────────────────
+    cm = confusion_matrix(labels, preds)
+    tn, fp, fn, tp = cm.ravel()
+    disp = ConfusionMatrixDisplay(cm, display_labels=["Normal (0)", "Pneumonia (1)"])
+    disp.plot(cmap=plt.cm.Blues)
+    plt.title(f"{label} - PneumoniaMNIST", fontweight="bold")
+    plt.savefig(os.path.join(out_dir, f"{name}_confusion_matrix.png"), dpi=300, bbox_inches="tight")
+    plt.close()
+
+    # ── ROC Curve ─────────────────────────────────────────────────────────────
+    fpr, tpr, _ = roc_curve(labels, probs)
+    roc_auc     = auc(fpr, tpr)
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.plot(fpr, tpr, color="darkorange", lw=2, label=f"ROC curve (AUC = {roc_auc:.4f})")
+    ax.plot([0, 1], [0, 1], color="navy", lw=2, linestyle="--", label="Random Guessing")
+    ax.set_xlim([0, 1]); ax.set_ylim([0, 1.05])
+    ax.set_xlabel("False Positive Rate (1 - Specificity)", fontweight="bold")
+    ax.set_ylabel("True Positive Rate (Sensitivity)", fontweight="bold")
+    ax.set_title(f"ROC - {label}", fontweight="bold")
+    ax.legend(loc="lower right")
+    plt.savefig(os.path.join(out_dir, f"{name}_roc_curve.png"), dpi=300, bbox_inches="tight")
+    plt.close()
+
+    # ── Score TXT ─────────────────────────────────────────────────────────────
+    sensitivity = tp / (tp + fn)
+    specificity = tn / (tn + fp)
+    accuracy    = (tp + tn) / (tp + tn + fp + fn)
+    report      = classification_report(labels, preds, target_names=["Normal (0)", "Pneumonia (1)"])
+
+    score_path = os.path.join(out_dir, f"{name}_score.txt")
+    with open(score_path, "w") as f:
+        f.write(f"{'='*50}\n")
+        f.write(f"CLASSIFICATION REPORT: {name.upper()}-AUGMENTED MODEL\n")
+        f.write(f"{'='*50}\n\n")
+        f.write(report)
+        f.write(f"\n{'='*50}\n")
+        f.write(f"CLINICAL METRICS\n")
+        f.write(f"{'='*50}\n")
+        f.write(f"Accuracy    : {accuracy:.4f} ({accuracy*100:.2f}%)\n")
+        f.write(f"Sensitivity : {sensitivity:.4f} ({sensitivity*100:.2f}%)\n")
+        f.write(f"Specificity : {specificity:.4f} ({specificity*100:.2f}%)\n")
+        f.write(f"AUC         : {roc_auc:.4f}\n")
+        f.write(f"TN={tn}  FP={fp}  FN={fn}  TP={tp}\n")
+
+    return {
+        "accuracy": accuracy, "sensitivity": sensitivity,
+        "specificity": specificity, "auc": roc_auc,
+        "tn": tn, "fp": fp, "fn": fn, "tp": tp,
+    }
+
+def save_summary(summary, out_dir):
+    """Save a master comparison table."""
+    path = os.path.join(out_dir, "SUMMARY_TABLE.txt")
+    with open(path, "w") as f:
+        header = f"{'Model':<12} {'Accuracy':>10} {'Sensitivity':>13} {'Specificity':>13} {'AUC':>8} {'TN':>5} {'FP':>5} {'FN':>5} {'TP':>5}"
+        f.write("="*len(header) + "\n")
+        f.write("MASTER COMPARISON TABLE - PneumoniaMNIST\n")
+        f.write("="*len(header) + "\n")
+        f.write(header + "\n")
+        f.write("-"*len(header) + "\n")
+        for name, m in summary.items():
+            f.write(
+                f"{name:<12} {m['accuracy']*100:>9.2f}% "
+                f"{m['sensitivity']*100:>12.2f}% "
+                f"{m['specificity']*100:>12.2f}% "
+                f"{m['auc']:>8.4f} "
+                f"{m['tn']:>5} {m['fp']:>5} {m['fn']:>5} {m['tp']:>5}\n"
+            )
+        f.write("="*len(header) + "\n")
+    print(f"\n✅ Summary table saved → {path}")
+
+def main():
+    device     = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Evaluating on: {device}\n")
+    val_loader = get_val_loader()
+    summary    = {}
+
+    for name, cfg in MODELS.items():
+        print(f"── Evaluating: {name} ──────────────────────────")
+        if not os.path.exists(cfg["weights"]):
+            print(f"   ⚠️  Weights not found: {cfg['weights']}\n")
+            continue
+
+        model = build_model(device)
+        model.load_state_dict(torch.load(cfg["weights"], map_location=device, weights_only=True))
+
+        preds, labels, probs = evaluate(model, val_loader, device)
+        out_dir = os.path.join(RESULTS_ROOT, name)
+        metrics = save_results(name, cfg["label"], preds, labels, probs, out_dir)
+        summary[name] = metrics
+
+        print(f"   Accuracy   : {metrics['accuracy']*100:.2f}%")
+        print(f"   Sensitivity: {metrics['sensitivity']*100:.2f}%")
+        print(f"   Specificity: {metrics['specificity']*100:.2f}%")
+        print(f"   AUC        : {metrics['auc']:.4f}")
+        print(f"   TN={metrics['tn']} FP={metrics['fp']} FN={metrics['fn']} TP={metrics['tp']}")
+        print(f"   ✅ Saved → {out_dir}\n")
+
+    save_summary(summary, RESULTS_ROOT)
+    print(f"\n🎉 All done! Results saved to: {RESULTS_ROOT}")
+
+if __name__ == "__main__":
+    main()

CNN/GradCam.py

@@ -0,0 +1,87 @@
+import os
+import torch
+import torch.nn as nn
+from torchvision import transforms, models
+import medmnist
+from medmnist import INFO
+import matplotlib.pyplot as plt
+import numpy as np
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+from pytorch_grad_cam.utils.image import show_cam_on_image
+
+def main():
+    # 1. Hardware Setup
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Generating Grad-CAM on: {device}")
+
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    info = INFO['pneumoniamnist']
+    DataClass = getattr(medmnist, info['python_class'])
+
+    # 2. Rebuild and Load the Frozen Model
+    print("Loading Baseline ResNet50...")
+    model = models.resnet50()
+    model.fc = nn.Linear(model.fc.in_features, 2)
+    weights_path = os.path.join(dataset_root, 'baseline_resnet50.pth')
+    model.load_state_dict(torch.load(weights_path, map_location=device, weights_only=True))
+    model = model.to(device)
+    model.eval() # Lock the model
+
+    # 3. Hook into the final layer
+    # Target layer4[-1], which is the final convolutional block before the classification head
+    target_layers = [model.layer4[-1]]
+    cam = GradCAM(model=model, target_layers=target_layers)
+
+    # 4. Grab a sample image (without mathematical augmentations)
+    val_dataset_raw = DataClass(split='val', download=False, size=224, root=dataset_root)
+    
+    # Mathematical preprocessing just for the model's brain
+    transform = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ])
+
+    sample_idx = 0
+    for i in range(len(val_dataset_raw)):
+        img, label = val_dataset_raw[i]
+        if label[0] == 1: 
+            sample_idx = i
+            break
+
+    raw_img, _ = val_dataset_raw[sample_idx]
+    
+    # Convert the raw grayscale image to RGB and scale to [0, 1] for the visual heatmap overlay
+    rgb_img = np.array(raw_img.convert('RGB'), dtype=np.float32) / 255.0
+
+    # Push the math-ready tensor to the GPU
+    input_tensor = transform(raw_img).unsqueeze(0).to(device)
+
+    # 5. Generate the Heatmap
+    # Show pneumonia
+    targets = [ClassifierOutputTarget(1)]
+    grayscale_cam = cam(input_tensor=input_tensor, targets=targets)[0, :]
+
+    # Overlay the red/yellow heatmap on the black and white X-ray
+    visualization = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)
+
+    # 6. Plot and Save for the Report
+    print("Generating Figure...")
+    fig, axes = plt.subplots(1, 2, figsize=(10, 5))
+    axes[0].imshow(rgb_img)
+    axes[0].set_title("Original X-Ray (Pneumonia)", fontweight='bold')
+    axes[0].axis('off')
+
+    axes[1].imshow(visualization)
+    axes[1].set_title("Grad-CAM Heatmap", fontweight='bold')
+    axes[1].axis('off')
+
+    save_path = os.path.join(dataset_root, 'gradcam_pneumonia.png')
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300)
+    print(f"Success! Image saved to: {save_path}")
+    plt.show()
+
+if __name__ == '__main__':
+    main()

CNN/Train_Hybrid_CNN.py

@@ -0,0 +1,117 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import transforms, models
+from torch.utils.data import DataLoader, Dataset, ConcatDataset
+from PIL import Image
+import medmnist
+from medmnist import INFO
+from tqdm import tqdm
+import numpy as np
+
+# 1. Custom Dataset Loader for GAN Images
+class SyntheticDataset(Dataset):
+    def __init__(self, folder_path, transform=None):
+        self.folder_path = folder_path
+        self.transform = transform
+        self.image_files = [f for f in os.listdir(folder_path) if f.endswith('.png')]
+
+    def __len__(self):
+        return len(self.image_files)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.folder_path, self.image_files[idx])
+        # Force load as grayscale to match the real X-rays perfectly
+        image = Image.open(img_path).convert('L')
+        
+        if self.transform:
+            image = self.transform(image)
+            
+        # Explicitly assign the "Normal (0)" label in the exact format MedMNIST uses
+        label = np.array([0])
+        return image, label
+
+def main():
+    # 2. Hardware Setup
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Training Hybrid CNN on: {device}")
+
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    synthetic_folder = os.path.join(dataset_root, "MaskGIT_Synthetic", "Normal_0")
+
+    # 3. Strict Preprocessing Pipeline
+    train_transform = transforms.Compose([
+        transforms.Resize(224),
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomRotation(10),
+        # Convert the 1-channel X-ray to 3-channel RGB for the ResNet
+        transforms.Grayscale(num_output_channels=3),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+    ])
+
+    # 4. Load the Real Dataset
+    print("Loading Real MedMNIST Data...")
+    info = INFO['pneumoniamnist']
+    DataClass = getattr(medmnist, info['python_class'])
+    real_train_dataset = DataClass(split='train', transform=train_transform, download=False, size=224, root=dataset_root)
+
+    # 5. Load the Synthetic Dataset
+    print("Loading Synthetic GAN Data...")
+    synthetic_train_dataset = SyntheticDataset(folder_path=synthetic_folder, transform=train_transform)
+
+    # 6. Data Fusion (Stitching them together)
+    print("Fusing Datasets into Hybrid Structure...")
+    hybrid_dataset = ConcatDataset([real_train_dataset, synthetic_train_dataset])
+    
+    # Num workers = 0 to prevent Windows I/O crashes
+    train_loader = DataLoader(dataset=hybrid_dataset, batch_size=32, shuffle=True, num_workers=0)
+    
+    print(f"Total Training Images: {len(hybrid_dataset)} (Balanced Class Distribution)")
+
+    # 7. Initialize a Fresh ResNet50
+    print("Initializing fresh ResNet50 architecture...")
+    model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
+    num_ftrs = model.fc.in_features
+    model.fc = nn.Linear(num_ftrs, 2)
+    model = model.to(device)
+
+    # 8. Training Parameters
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=1e-4)
+    num_epochs = 10
+
+    # 9. The Training Loop
+    for epoch in range(num_epochs):
+        model.train()
+        running_loss = 0.0
+        correct = 0
+        total = 0
+        
+        loop = tqdm(train_loader, leave=True)
+        for images, labels in loop:
+            images = images.to(device)
+            labels = labels.to(device).squeeze().long()
+            
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            
+            running_loss += loss.item()
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+            
+            loop.set_description(f"Epoch [{epoch+1}/{num_epochs}]")
+            loop.set_postfix(loss=loss.item(), acc=100.*correct/total)
+
+    # 10. Save the Final Hybrid Brain
+    save_path = os.path.join(dataset_root, 'hybrid_maskgit_resnet50.pth')
+    torch.save(model.state_dict(), save_path)
+    print(f"\nHybrid Training Complete! Weights saved to: {save_path}")
+
+if __name__ == '__main__':
+    main()

CNN/scorebaeline.txt

@@ -0,0 +1,22 @@
+==================================================
+
+CLASSIFICATION REPORT
+
+==================================================
+
+               precision    recall  f1-score   support
+
+
+
+   Normal (0)       0.99      0.93      0.96       135
+
+Pneumonia (1)       0.97      1.00      0.99       389
+
+
+
+     accuracy                           0.98       524
+
+    macro avg       0.98      0.96      0.97       524
+
+ weighted avg       0.98      0.98      0.98       524
+

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install dependencies first (for faster caching)
+COPY hf_requirements.txt .
+RUN pip install --no-cache-dir -r hf_requirements.txt
+
+# Copy only the necessary code and weights
+# We copy gui/, CNN/, EBM/, VAE/ because main.py imports from them
+COPY gui/ ./gui/
+COPY CNN/ ./CNN/
+COPY EBM/ ./EBM/
+COPY VAE/ ./VAE/
+
+# Copy the pre-generated images and metrics
+COPY results/ ./results/
+
+# Copy the model weights needed for live inference
+COPY *.pth ./
+
+# Hugging Face Spaces require web apps to run on port 7860
+EXPOSE 7860
+
+# Run FastAPI
+CMD ["uvicorn", "gui.backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

EBMs/Harvest_EBM.py

@@ -0,0 +1,99 @@
+import os
+import torch
+import torch.nn as nn
+from torchvision.utils import save_image
+from tqdm import tqdm
+
+# 1. Rebuild the Exact EBM Architecture
+class EnergyModel(nn.Module):
+    def __init__(self):
+        super(EnergyModel, self).__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(1, 32, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(32, 64, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(64, 128, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(128, 256, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(256, 512, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Flatten(),
+            nn.Linear(512 * 7 * 7, 1)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+# 2. The Langevin Sampler (Requires gradients to simulate physics!)
+def sample_langevin(model, x, steps=100, step_size=10, noise_scale=0.005):
+    x = x.clone().detach().requires_grad_(True)
+    
+    # Enable gradients here, even if the main loop is evaluating
+    with torch.enable_grad():
+        for _ in range(steps):
+            energy = model(x)
+            grad = torch.autograd.grad(energy.sum(), x, only_inputs=True)[0]
+            
+            # Move down the energy slope, add thermodynamic noise
+            x.data -= step_size * grad + noise_scale * torch.randn_like(x)
+            x.data = torch.clamp(x.data, -1.0, 1.0)
+            
+    return x.detach()
+
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Targeting device for EBM Harvest: {device}")
+
+    # Windows path
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    output_dir = os.path.join(dataset_root, "EBM_Synthetic", "Normal_0")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # 3. Load the Thermodynamic Brain
+    print("Loading EBM weights...")
+    model = EnergyModel().to(device)
+    weight_path = os.path.join(dataset_root, "EBM_Outputs", "ebm_baseline.pth")
+    
+    if not os.path.exists(weight_path):
+        print(f"Error: Weights not found at {weight_path}")
+        return
+
+    model.load_state_dict(torch.load(weight_path, map_location=device, weights_only=True))
+    model.eval()
+
+    # 4. Harvest Parameters
+    total_images_needed = 2600
+    batch_size = 64 # Pushing batch size up to maximize CUDA parallelization
+    generated_count = 0
+
+    print(f"Commencing Langevin thermodynamic sampling for {total_images_needed} lungs...")
+    print("Warning: This will take significantly longer than GAN/VAE harvesting!")
+
+    # No torch.no_grad() globally because Langevin dynamics require gradients
+    with tqdm(total=total_images_needed, desc="Cooling Static") as pbar:
+        while generated_count < total_images_needed:
+            current_batch_size = min(batch_size, total_images_needed - generated_count)
+            
+            # Start with pure random static [-1, 1]
+            initial_noise = (torch.rand(current_batch_size, 1, 224, 224, device=device) * 2 - 1)
+            
+            # Run the physics simulation (100 steps for higher fidelity)
+            fake_images = sample_langevin(model, initial_noise, steps=100)
+            
+            # Denormalize from [-1, 1] back to [0, 1]
+            fake_images = (fake_images + 1) / 2.0
+            
+            # Save the synthesized lungs
+            for i in range(current_batch_size):
+                img_path = os.path.join(output_dir, f"ebm_normal_{generated_count}.png")
+                save_image(fake_images[i], img_path)
+                generated_count += 1
+                
+            pbar.update(current_batch_size)
+
+    print(f"\nSuccess! EBM Harvest complete. Images stored in: {output_dir}")
+
+if __name__ == "__main__":
+    main()

EBMs/Train_EBM.py

@@ -0,0 +1,151 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import transforms
+from torchvision.utils import save_image
+from torch.utils.data import DataLoader, Subset
+import medmnist
+from medmnist import INFO
+from tqdm import tqdm
+
+# ==========================================
+# 1. The Energy Function (A simple CNN)
+# ==========================================
+# This network's only job is to output a single scalar "Energy" score.
+# Low score = Real Lung. High score = Fake/Noise.
+class EnergyModel(nn.Module):
+    def __init__(self):
+        super(EnergyModel, self).__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(1, 32, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(32, 64, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(64, 128, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(128, 256, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(256, 512, 4, 2, 1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Flatten(),
+            nn.Linear(512 * 7 * 7, 1) # Output a single number
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+# ==========================================
+# 2. Langevin Dynamics (The Thermodynamic Generator)
+# ==========================================
+def sample_langevin(model, x, steps=60, step_size=10, noise_scale=0.005):
+    # This is Markov Chain Monte Carlo (MCMC)
+    # Detach x to start a fresh computational graph
+    x = x.clone().detach().requires_grad_(True)
+    
+    for _ in range(steps):
+        # Calculate the energy of the current image
+        energy = model(x)
+
+        # Sum the energy so autograd can compute gradients for the whole batch at once
+        grad = torch.autograd.grad(energy.sum(), x, only_inputs=True)[0]
+        
+        # Langevin Equation: 
+        # Move pixels in the OPPOSITE direction of the gradient (to lower the energy)
+        # Add a tiny bit of random thermodynamic heat (noise) to prevent getting stuck
+        x.data -= step_size * grad + noise_scale * torch.randn_like(x)
+        
+        # Clamp pixels to stay within valid grayscale image bounds [-1, 1]
+        x.data = torch.clamp(x.data, -1.0, 1.0)
+        
+    return x.detach() # Strip the autograd receipt so it doesn't cause an OOM!
+
+# ==========================================
+# 3. The Training Loop
+# ==========================================
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Igniting Thermodynamic EBM on: {device}")
+
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    out_dir = os.path.join(dataset_root, "EBM_Outputs")
+    os.makedirs(out_dir, exist_ok=True)
+
+    # We scale to [-1, 1] for stable gradient flows in Langevin dynamics
+    transform = transforms.Compose([
+        transforms.Resize(224),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5], std=[0.5])
+    ])
+
+    print("Loading Normal Lungs...")
+    info = INFO['pneumoniamnist']
+    DataClass = getattr(medmnist, info['python_class'])
+    full_dataset = DataClass(split='train', transform=transform, download=False, size=224, root=dataset_root)
+    
+    # Isolate healthy lungs
+    normal_indices = [i for i in range(len(full_dataset)) if full_dataset[i][1][0] == 0]
+    normal_dataset = Subset(full_dataset, normal_indices)
+    dataloader = DataLoader(normal_dataset, batch_size=32, shuffle=True, num_workers=0)
+
+    model = EnergyModel().to(device)
+    optimizer = optim.Adam(model.parameters(), lr=1e-4)
+
+    num_epochs = 100
+    print("Commencing Energy Optimization...")
+
+    for epoch in range(num_epochs):
+        model.train()
+        loop = tqdm(dataloader, leave=True)
+        
+        for real_images, _ in loop:
+            real_images = real_images.to(device)
+            batch_size = real_images.size(0)
+            
+            # 1. Start with pure random static
+            initial_noise = torch.rand_like(real_images) * 2 - 1 
+            
+            # 2. Cool the static down into fake lungs via Langevin Dynamics
+            fake_images = sample_langevin(model, initial_noise, steps=60)
+            
+            optimizer.zero_grad()
+            
+            # 3. Calculate Energy for both Real and Fake
+            real_energy = model(real_images)
+            fake_energy = model(fake_images)
+            
+            # 4. Contrastive Divergence Loss
+            # Real Energy low (negative), Fake Energy high (positive)
+            loss = real_energy.mean() - fake_energy.mean()
+            
+            # Add L2 Regularization (Prevents the energy values from exploding to infinity)
+            loss += 0.001 * (real_energy ** 2 + fake_energy ** 2).mean()
+            
+            loss.backward()
+            
+            # Gradient clipping to prevent thermodynamic explosions
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+            optimizer.step()
+            
+            loop.set_description(f"EBM Epoch [{epoch+1}/{num_epochs}]")
+            loop.set_postfix(Loss=loss.item(), Real_E=real_energy.mean().item(), Fake_E=fake_energy.mean().item())
+
+        # Save visual progression
+        if (epoch + 1) % 10 == 0:
+            model.eval()
+            print(f"\nGenerating checkpoint samples for Epoch {epoch+1}...")
+            with torch.no_grad():
+                # Use gradients to sample, enable grad temporarily
+                with torch.enable_grad():
+                    test_noise = (torch.rand(16, 1, 224, 224, device=device) * 2 - 1)
+                    test_samples = sample_langevin(model, test_noise, steps=100)
+                
+                # Denormalize from [-1, 1] back to [0, 1] for saving
+                test_samples = (test_samples + 1) / 2.0
+                save_image(test_samples, os.path.join(out_dir, f'ebm_sample_{epoch+1}.png'), nrow=4)
+
+    torch.save(model.state_dict(), os.path.join(out_dir, 'ebm_baseline.pth'))
+    print("\nEBM Training Complete.")
+
+if __name__ == '__main__':
+    main()

GAN/GAN_Architecture.py

@@ -0,0 +1,105 @@
+import torch
+import torch.nn as nn
+
+class Generator(nn.Module):
+    def __init__(self, latent_dim=100):
+        super(Generator, self).__init__()
+        
+        # Mapping the 100-dimension noise vector to a 7x7 spatial foundation
+        self.init_size = 7
+        self.l1 = nn.Sequential(nn.Linear(latent_dim, 256 * self.init_size ** 2))
+
+        # Using kernel=4, stride=2, padding=1 perfectly doubles the resolution at each step
+        self.conv_blocks = nn.Sequential(
+            nn.BatchNorm2d(256),
+            
+            # 7x7 -> 14x14
+            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),
+            nn.BatchNorm2d(128),
+            nn.LeakyReLU(0.2, inplace=True),
+            
+            # 14x14 -> 28x28
+            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),
+            nn.BatchNorm2d(64),
+            nn.LeakyReLU(0.2, inplace=True),
+            
+            # 28x28 -> 56x56
+            nn.ConvTranspose2d(64, 32, kernel_size=4, stride=2, padding=1),
+            nn.BatchNorm2d(32),
+            nn.LeakyReLU(0.2, inplace=True),
+            
+            # 56x56 -> 112x112
+            nn.ConvTranspose2d(32, 16, kernel_size=4, stride=2, padding=1),
+            nn.BatchNorm2d(16),
+            nn.LeakyReLU(0.2, inplace=True),
+            
+            # 112x112 -> 224x224
+            # Output is 1 channel (Grayscale) and uses Tanh to map pixels to [-1, 1]
+            nn.ConvTranspose2d(16, 1, kernel_size=4, stride=2, padding=1),
+            nn.Tanh()
+        )
+
+    def forward(self, z):
+        out = self.l1(z)
+        out = out.view(out.shape[0], 256, self.init_size, self.init_size)
+        img = self.conv_blocks(out)
+        return img
+
+
+class Discriminator(nn.Module):
+    def __init__(self):
+        super(Discriminator, self).__init__()
+
+        def discriminator_block(in_filters, out_filters, bn=True):
+                    block = [
+                        # Wrap the convolution in spectral normalization
+                        nn.utils.spectral_norm(nn.Conv2d(in_filters, out_filters, kernel_size=4, stride=2, padding=1)),
+                        nn.LeakyReLU(0.2, inplace=True),
+                        nn.Dropout2d(0.25)
+                    ]
+                    if bn:
+                        block.append(nn.BatchNorm2d(out_filters, 0.8))
+                    return block
+
+        self.model = nn.Sequential(
+            # Input: 1 x 224 x 224
+            *discriminator_block(1, 16, bn=False), # 112x112
+            *discriminator_block(16, 32),          # 56x56
+            *discriminator_block(32, 64),          # 28x28
+            *discriminator_block(64, 128),         # 14x14
+            *discriminator_block(128, 256),        # 7x7
+        )
+
+        # The downsampled image is flattened and fed into a single neuron to guess: Real or Fake?
+        ds_size = 7
+        self.adv_layer = nn.Sequential(
+            nn.Linear(256 * ds_size ** 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, img):
+        out = self.model(img)
+        out = out.view(out.shape[0], -1)
+        validity = self.adv_layer(out)
+        return validity
+    
+if __name__ == "__main__":
+    print("Testing GAN Dimensions...")
+    
+    # 1. Create a dummy noise vector (Batch Size of 2, 100 random numbers each)
+    latent_dim = 100
+    z = torch.randn(2, latent_dim)
+    
+    # 2. Test Generator
+    gen = Generator(latent_dim)
+    fake_imgs = gen(z)
+    print(f"Generator Output Shape: {fake_imgs.shape}") 
+    # EXPECTED: [2, 1, 224, 224] (2 images, 1 channel, 224x224 pixels)
+    
+    # 3. Test Discriminator
+    disc = Discriminator()
+    validity = disc(fake_imgs)
+    print(f"Discriminator Output Shape: {validity.shape}") 
+    # EXPECTED: [2, 1] (2 guesses between 0.0 and 1.0)
+    
+    print("If you see [2, 1, 224, 224] and [2, 1], the architecture is perfectly locked in!")

GAN/Harvest_Fakes.py

@@ -0,0 +1,54 @@
+import os
+import torch
+from torchvision.utils import save_image
+from tqdm import tqdm
+
+# Import the blueprint
+from GAN_Architecture import Generator
+
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Harvesting synthetic data on: {device}")
+
+    # Set up the exact folder structure needed for easy PyTorch loading later
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    synthetic_dir = os.path.join(dataset_root, "Synthetic_Data", "Normal_0")
+    os.makedirs(synthetic_dir, exist_ok=True)
+
+    # 1. Load the frozen brain
+    print("Waking up the trained Generator...")
+    latent_dim = 100
+    generator = Generator(latent_dim=latent_dim).to(device)
+    
+    weights_path = os.path.join(dataset_root, 'generator_weights.pth')
+    generator.load_state_dict(torch.load(weights_path, map_location=device, weights_only=True))
+    generator.eval() # CRITICAL: Lock the gradients
+
+    # 2. Harvesting Parameters
+    num_images_needed = 2600
+    batch_size = 100
+    batches = num_images_needed // batch_size
+
+    print(f"Generating {num_images_needed} high-resolution synthetic X-rays...")
+    
+    img_counter = 0
+    with torch.no_grad():
+        for i in tqdm(range(batches), desc="Harvesting Batches"):
+            # Generate pure noise
+            z = torch.randn(batch_size, latent_dim, device=device)
+            
+            # Pass noise through the GAN to hallucinate the images
+            fake_imgs = generator(z)
+            
+            # Save each image individually to the NVMe drive
+            for j in range(fake_imgs.size(0)):
+                # Un-normalize from [-1, 1] back to standard [0, 1] pixel values
+                save_path = os.path.join(synthetic_dir, f"synthetic_normal_{img_counter}.png")
+                save_image(fake_imgs[j], save_path, normalize=True)
+                img_counter += 1
+
+    print(f"\nHarvest Complete! {img_counter} synthetic healthy lungs saved to:")
+    print(synthetic_dir)
+
+if __name__ == '__main__':
+    main()

GAN/Train_GAN.py

@@ -0,0 +1,119 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import transforms
+from torch.utils.data import DataLoader, Subset
+import torchvision.utils as vutils
+import medmnist
+from medmnist import INFO
+from tqdm import tqdm
+
+# Import your blueprints
+from GAN_Architecture import Generator, Discriminator
+
+def main():
+    # 1. Hardware & Setup
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Training GAN on: {device}")
+
+    dataset_root = r"C:\Users\USER\Downloads\MedMNIST_Data"
+    os.makedirs(os.path.join(dataset_root, "GAN_Outputs"), exist_ok=True)
+
+    # 2. Hyperparameters (The standard for stable GANs)
+    latent_dim = 100
+    lr = 0.0002
+    b1 = 0.5     
+    b2 = 0.999   
+    num_epochs = 300   # Pushed from 50 to 300
+    batch_size = 128   # Taking advantage of the VRAM
+
+    # 3. Load & Filter the Dataset (CRITICAL STEP)
+    # Only grayscale images mathematically bounded to [-1, 1]
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5], std=[0.5]) 
+    ])
+
+    info = INFO['pneumoniamnist']
+    DataClass = getattr(medmnist, info['python_class'])
+    
+    print("Loading dataset and isolating 'Normal (0)' lungs...")
+    full_dataset = DataClass(split='train', transform=transform, download=False, size=224, root=dataset_root)
+    
+    # Filter out all Pneumonia (1) images.
+    normal_indices = [i for i in range(len(full_dataset)) if full_dataset[i][1][0] == 0]
+    normal_dataset = Subset(full_dataset, normal_indices)
+    
+    # num_workers=0 to prevent Windows multiprocessing crashes
+    # Pass the new batch_size variable here
+    dataloader = DataLoader(normal_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
+    print(f"Isolated {len(normal_dataset)} healthy lung images for training.")
+
+    # 4. Initialize Networks
+    generator = Generator(latent_dim).to(device)
+    discriminator = Discriminator().to(device)
+
+    # 5. Loss & Optimizers
+    adversarial_loss = nn.BCELoss() # Binary Cross Entropy
+    optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(b1, b2))
+    optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(b1, b2))
+
+    # Create a static noise vector to visually track how the Generator improves over time
+    fixed_noise = torch.randn(16, latent_dim, device=device)
+
+    # 6. The Arena (Training Loop)
+    for epoch in range(num_epochs):
+        loop = tqdm(dataloader, leave=True)
+        for i, (imgs, _) in enumerate(loop):
+            
+            # Ground truth labels (Real = 1.0, Fake = 0.0)
+            # Change from 1.0 to 0.9 for real images
+            valid = torch.full((imgs.size(0), 1), 0.9, device=device, requires_grad=False)
+            # Change from 0.0 to 0.1 for fake images
+            fake = torch.full((imgs.size(0), 1), 0.1, device=device, requires_grad=False)
+            
+            real_imgs = imgs.to(device)
+
+            # -----------------
+            #  Train Generator
+            # -----------------
+            optimizer_G.zero_grad()
+            
+            # Generate a batch of images from random noise
+            z = torch.randn(imgs.size(0), latent_dim, device=device)
+            gen_imgs = generator(z)
+            
+            # The Generator's goal is to trick the Discriminator into guessing 'valid' (1.0)
+            g_loss = adversarial_loss(discriminator(gen_imgs), valid)
+            g_loss.backward()
+            optimizer_G.step()
+
+            # ---------------------
+            #  Train Discriminator
+            # ---------------------
+            optimizer_D.zero_grad()
+            
+            real_loss = adversarial_loss(discriminator(real_imgs), valid)
+            fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
+            
+            d_loss = (real_loss + fake_loss) / 2
+            d_loss.backward()
+            optimizer_D.step()
+
+            loop.set_description(f"Epoch [{epoch+1}/{num_epochs}]")
+            loop.set_postfix(D_loss=d_loss.item(), G_loss=g_loss.item())
+
+        # Save a visual sample of the hallucinated lungs every 5 epochs
+        if (epoch + 1) % 5 == 0:
+            with torch.no_grad():
+                sample_imgs = generator(fixed_noise)
+                # Un-normalize from [-1, 1] back to [0, 1] for saving as a standard image file
+                vutils.save_image(sample_imgs, os.path.join(dataset_root, "GAN_Outputs", f"epoch_{epoch+1}.png"), nrow=4, normalize=True)
+
+    # 7. Save the final Generator Brain
+    torch.save(generator.state_dict(), os.path.join(dataset_root, 'generator_weights.pth'))
+    print("GAN Training Complete! Generator saved.")
+
+if __name__ == '__main__':
+    main()

baseline_resnet50.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6924d57f89b224f0118469826ceca25a6b4ea61e8ad22345d1cd88dd799e87a3
+size 94369787

gui/backend/main.py

@@ -0,0 +1,338 @@
+import io
+import base64
+import math
+import random
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms, models
+from PIL import Image
+
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+# ── Paths ─────────────────────────────────────────────────────────────────────
+PROJECT_ROOT = Path(r"C:\Users\Brian ooi\Documents\code\CVPR\CVPRAssignment")
+RESULTS = PROJECT_ROOT / "results"
+
+CLASSIFIER_WEIGHTS = {
+    "Baseline":  PROJECT_ROOT / "baseline_resnet50.pth",
+    "GAN":       RESULTS / "GAN-20260621T100120Z-3-001/GAN/hybrid_resnet50.pth",
+    "EBM":       RESULTS / "EBM-20260621T100117Z-3-001/EBM/hybrid_ebm_resnet50.pth",
+    "DiT":       RESULTS / "DiT-20260621T100114Z-3-001/DiT/hybrid_dit_resnet50.pth",
+    "Diffusion": RESULTS / "Diffusion-20260621T100111Z-3-001/Diffusion/hybrid_diffusion_resnet50.pth",
+    "MaskGIT":   RESULTS / "MaskGiT-20260621T100123Z-3-001/MaskGiT/hybrid_maskgit_resnet50.pth",
+    "VAE":       RESULTS / "VAE-20260621T100129Z-3-001/VAE/hybrid_vae_resnet50.pth",
+}
+
+GAN_GEN_PATH = RESULTS / "GAN-20260621T100120Z-3-001/GAN/generator_weights.pth"
+EBM_PATH     = RESULTS / "EBM-20260621T100117Z-3-001/EBM/EBM_Outputs/ebm_baseline.pth"
+VAE_PATH     = RESULTS / "VAE-20260621T100129Z-3-001/VAE/vae_baseline.pth"
+
+# Pre-generated epoch sample grid image directories (instant serving, no inference)
+SAMPLE_DIRS = {
+    "EBM":      RESULTS / "EBM-20260621T100117Z-3-001/EBM/EBM_Outputs",
+    "DiT":      RESULTS / "DiT-20260621T100114Z-3-001/DiT/DiT_Outputs",
+    "Diffusion":RESULTS / "Diffusion-20260621T100111Z-3-001/Diffusion/Diffusion_Outputs",
+    "MaskGIT":  RESULTS / "MaskGiT-20260621T100123Z-3-001/MaskGiT/MaskGIT_Outputs",
+}
+
+# ── GAN Architecture ──────────────────────────────────────────────────────────
+class Generator(nn.Module):
+    def __init__(self, latent_dim=100):
+        super().__init__()
+        self.init_size = 7
+        self.l1 = nn.Sequential(nn.Linear(latent_dim, 256 * self.init_size ** 2))
+        self.conv_blocks = nn.Sequential(
+            nn.BatchNorm2d(256),
+            nn.ConvTranspose2d(256, 128, 4, 2, 1), nn.BatchNorm2d(128), nn.LeakyReLU(0.2, inplace=True),
+            nn.ConvTranspose2d(128, 64,  4, 2, 1), nn.BatchNorm2d(64),  nn.LeakyReLU(0.2, inplace=True),
+            nn.ConvTranspose2d(64,  32,  4, 2, 1), nn.BatchNorm2d(32),  nn.LeakyReLU(0.2, inplace=True),
+            nn.ConvTranspose2d(32,  16,  4, 2, 1), nn.BatchNorm2d(16),  nn.LeakyReLU(0.2, inplace=True),
+            nn.ConvTranspose2d(16,   1,  4, 2, 1), nn.Tanh(),
+        )
+    def forward(self, z):
+        out = self.l1(z)
+        out = out.view(out.shape[0], 256, self.init_size, self.init_size)
+        return self.conv_blocks(out)
+
+# ── EBM Architecture ──────────────────────────────────────────────────────────
+class EnergyModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(1,   32,  4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(32,  64,  4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(64,  128, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(128, 256, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv2d(256, 512, 4, 2, 1), nn.LeakyReLU(0.2, inplace=True),
+            nn.Flatten(), nn.Linear(512 * 7 * 7, 1),
+        )
+    def forward(self, x):
+        return self.net(x)
+
+def sample_langevin(model, x, steps=25, step_size=10, noise_scale=0.005):
+    x = x.clone().detach().requires_grad_(True)
+    with torch.enable_grad():
+        for _ in range(steps):
+            energy = model(x)
+            grad = torch.autograd.grad(energy.sum(), x, only_inputs=True)[0]
+            x.data -= step_size * grad + noise_scale * torch.randn_like(x)
+            x.data = torch.clamp(x.data, -1.0, 1.0)
+    return x.detach()
+
+# ── VAE Architecture ──────────────────────────────────────────────────────────
+class VAE(nn.Module):
+    def __init__(self, latent_dim=128):
+        super().__init__()
+        self.enc1 = nn.Conv2d(1, 32, 4, 2, 1)
+        self.enc2 = nn.Conv2d(32, 64, 4, 2, 1)
+        self.enc3 = nn.Conv2d(64, 128, 4, 2, 1)
+        self.enc4 = nn.Conv2d(128, 256, 4, 2, 1)
+        self.enc5 = nn.Conv2d(256, 512, 4, 2, 1)
+        self.fc_mu     = nn.Linear(512 * 7 * 7, latent_dim)
+        self.fc_logvar = nn.Linear(512 * 7 * 7, latent_dim)
+        self.dec_fc = nn.Linear(latent_dim, 512 * 7 * 7)
+        self.dec1 = nn.ConvTranspose2d(512, 256, 4, 2, 1)
+        self.dec2 = nn.ConvTranspose2d(256, 128, 4, 2, 1)
+        self.dec3 = nn.ConvTranspose2d(128, 64, 4, 2, 1)
+        self.dec4 = nn.ConvTranspose2d(64, 32, 4, 2, 1)
+        self.dec5 = nn.ConvTranspose2d(32, 1, 4, 2, 1)
+
+    def decode(self, z):
+        x = F.relu(self.dec_fc(z))
+        x = x.view(x.size(0), 512, 7, 7)
+        x = F.relu(self.dec1(x))
+        x = F.relu(self.dec2(x))
+        x = F.relu(self.dec3(x))
+        x = F.relu(self.dec4(x))
+        return torch.sigmoid(self.dec5(x))
+
+    def forward(self, x):
+        x = F.relu(self.enc1(x)); x = F.relu(self.enc2(x))
+        x = F.relu(self.enc3(x)); x = F.relu(self.enc4(x))
+        x = F.relu(self.enc5(x)); x = x.view(x.size(0), -1)
+        mu, logvar = self.fc_mu(x), self.fc_logvar(x)
+        std = torch.exp(0.5 * logvar)
+        z = mu + std * torch.randn_like(std)
+        return self.decode(z), mu, logvar
+
+# ── Model Cache ───────────────────────────────────────────────────────────────
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+_cache: dict = {}
+
+def get_gan():
+    if "gan" not in _cache:
+        gen = Generator(latent_dim=100).to(device)
+        gen.load_state_dict(torch.load(GAN_GEN_PATH, map_location=device, weights_only=True))
+        gen.eval(); _cache["gan"] = gen
+    return _cache["gan"]
+
+def get_ebm():
+    if "ebm" not in _cache:
+        ebm = EnergyModel().to(device)
+        ebm.load_state_dict(torch.load(EBM_PATH, map_location=device, weights_only=True))
+        ebm.eval(); _cache["ebm"] = ebm
+    return _cache["ebm"]
+
+def get_vae():
+    if "vae" not in _cache:
+        vae = VAE(latent_dim=128).to(device)
+        vae.load_state_dict(torch.load(VAE_PATH, map_location=device, weights_only=True))
+        vae.eval(); _cache["vae"] = vae
+    return _cache["vae"]
+
+def get_classifier(name: str):
+    key = f"clf_{name}"
+    if key not in _cache:
+        m = models.resnet50()
+        m.fc = nn.Linear(m.fc.in_features, 2)
+        m.load_state_dict(torch.load(CLASSIFIER_WEIGHTS[name], map_location=device, weights_only=True))
+        m.eval(); m.to(device); _cache[key] = m
+    return _cache[key]
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+def tensor_to_b64(t: torch.Tensor) -> str:
+    arr = t.squeeze().cpu().numpy()
+    arr = np.clip(arr * 255, 0, 255).astype(np.uint8)
+    pil = Image.fromarray(arr, mode="L").convert("RGB")
+    buf = io.BytesIO(); pil.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+def pil_to_b64(pil: Image.Image) -> str:
+    pil = pil.convert("RGB")
+    buf = io.BytesIO(); pil.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+def grid_png_to_tiles(path: Path, n: int = 3) -> list[str]:
+    """Crop n individual tiles from a 4x4 grid image and return as base64 list."""
+    img = Image.open(path).convert("RGB")
+    w, h = img.size
+    cols, rows = 4, 4
+    tw, th = w // cols, h // rows
+    tiles = []
+    positions = random.sample(range(cols * rows), min(n, cols * rows))
+    for pos in positions:
+        r, c = divmod(pos, cols)
+        tile = img.crop((c * tw, r * th, (c+1) * tw, (r+1) * th))
+        tile = tile.resize((224, 224), Image.LANCZOS)
+        buf = io.BytesIO(); tile.save(buf, format="PNG")
+        tiles.append(base64.b64encode(buf.getvalue()).decode())
+    return tiles
+
+def get_sample_tiles(model_key: str, n: int = 3) -> list[str]:
+    """Return n sample images from pre-generated epoch outputs."""
+    sample_dir = SAMPLE_DIRS.get(model_key)
+    if not sample_dir or not sample_dir.exists():
+        return []
+    pngs = list(sample_dir.glob("*.png"))
+    # Prefer later epoch samples (higher quality)
+    pngs.sort()
+    # Pick from the last half of available samples
+    best = pngs[len(pngs)//2:] if len(pngs) > 1 else pngs
+    chosen = random.sample(best, min(n, len(best)))
+    results = []
+    for p in chosen:
+        results.extend(grid_png_to_tiles(p, n=1))
+        if len(results) >= n:
+            break
+    return results[:n]
+
+# ── App ───────────────────────────────────────────────────────────────────────
+app = FastAPI(title="CVPR Medical Imaging GUI")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "device": str(device)}
+
+@app.get("/metrics_images")
+def metrics_images():
+    baseline_cm = RESULTS / "CNN-20260621T100109Z-3-001/CNN/Confusion Matrixabseline.png"
+    gan_cm = RESULTS / "GAN-20260621T100120Z-3-001/GAN/hybrid_confusion_matrix.png"
+    ebm_cm = RESULTS / "EBM-20260621T100117Z-3-001/EBM/hybrid_ebm_confusion_matrix.png"
+    
+    baseline_roc = RESULTS / "CNN-20260621T100109Z-3-001/CNN/rocbaseline.png"
+    gan_roc = RESULTS / "GAN-20260621T100120Z-3-001/GAN/roc_curvehybrid.png"
+    ebm_roc = RESULTS / "EBM-20260621T100117Z-3-001/EBM/roc_curveebm.png"
+
+    def to_b64(path):
+        if not path.exists(): return None
+        return pil_to_b64(Image.open(path))
+
+    return {
+        "Baseline": {"cm": to_b64(baseline_cm), "roc": to_b64(baseline_roc)},
+        "GAN": {"cm": to_b64(gan_cm), "roc": to_b64(gan_roc)},
+        "EBM": {"cm": to_b64(ebm_cm), "roc": to_b64(ebm_roc)},
+    }
+
+@app.get("/dataset_samples")
+def dataset_samples():
+    import medmnist
+    from medmnist import PneumoniaMNIST
+    dataset = PneumoniaMNIST(split='test', download=True)
+    normal_imgs = []
+    pneumonia_imgs = []
+    
+    for img, label in dataset:
+        if label[0] == 0 and len(normal_imgs) < 3:
+            normal_imgs.append(pil_to_b64(img))
+        elif label[0] == 1 and len(pneumonia_imgs) < 3:
+            pneumonia_imgs.append(pil_to_b64(img))
+        if len(normal_imgs) == 3 and len(pneumonia_imgs) == 3:
+            break
+            
+    return {"normal": normal_imgs, "pneumonia": pneumonia_imgs}
+
+@app.post("/augment")
+async def augment(file: UploadFile = File(...)):
+    raw = await file.read()
+    pil = Image.open(io.BytesIO(raw)).convert("L").resize((224, 224), Image.LANCZOS)
+    aug_list = [
+        ("Original",      transforms.Compose([transforms.Resize((224, 224))])),
+        ("H-Flip",        transforms.Compose([transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(p=1.0)])),
+        ("Rotation ±15°", transforms.Compose([transforms.Resize((224, 224)), transforms.RandomRotation(15)])),
+        ("Brightness",    transforms.Compose([transforms.Resize((224, 224)), transforms.ColorJitter(brightness=0.5, contrast=0.4)])),
+        ("Gaussian Blur", transforms.Compose([transforms.Resize((224, 224)), transforms.GaussianBlur(kernel_size=11, sigma=(2, 4))])),
+        ("Random Crop",   transforms.Compose([transforms.Resize((256, 256)), transforms.RandomCrop(224)])),
+    ]
+    results = [{"label": lbl, "image": pil_to_b64(t(pil))} for lbl, t in aug_list]
+    return {"augmentations": results}
+
+@app.post("/generate_all")
+async def generate_all(n: int = 3):
+    """Generate/retrieve n samples from all 6 generative models."""
+    n = min(max(n, 1), 4)
+    output = {}
+
+    # GAN — live generation (fast)
+    gen = get_gan()
+    z = torch.randn(n, 100, device=device)
+    with torch.no_grad():
+        fake = gen(z)
+    output["GAN"] = [tensor_to_b64((fake[i] + 1) / 2.0) for i in range(n)]
+
+    # VAE — live generation (just decoder, very fast)
+    vae = get_vae()
+    z_vae = torch.randn(n, 128, device=device)
+    with torch.no_grad():
+        vae_out = vae.decode(z_vae)
+    output["VAE"] = [tensor_to_b64(vae_out[i]) for i in range(n)]
+
+    # EBM — serve from pre-generated epoch samples (Langevin is slow on CPU)
+    output["EBM"] = get_sample_tiles("EBM", n)
+
+    # DiT — serve from pre-generated epoch samples (1000-step denoising is slow)
+    output["DiT"] = get_sample_tiles("DiT", n)
+
+    # Diffusion — serve from pre-generated epoch samples
+    output["Diffusion"] = get_sample_tiles("Diffusion", n)
+
+    # MaskGIT — serve from pre-generated epoch samples
+    output["MaskGIT"] = get_sample_tiles("MaskGIT", n)
+
+    return output
+
+# Keep the old /generate endpoint for backward compatibility
+@app.post("/generate")
+async def generate(n: int = 3):
+    n = min(max(n, 1), 6)
+    gen = get_gan()
+    z = torch.randn(n, 100, device=device)
+    with torch.no_grad():
+        fake = gen(z)
+    gan_imgs = [tensor_to_b64((fake[i] + 1) / 2.0) for i in range(n)]
+    ebm = get_ebm()
+    noise = torch.rand(n, 1, 224, 224, device=device) * 2 - 1
+    ebm_raw = sample_langevin(ebm, noise, steps=25)
+    ebm_imgs = [tensor_to_b64((ebm_raw[i] + 1) / 2.0) for i in range(n)]
+    return {"gan": gan_imgs, "ebm": ebm_imgs}
+
+@app.post("/classify")
+async def classify(file: UploadFile = File(...), model_name: str = Form("Baseline")):
+    if model_name not in CLASSIFIER_WEIGHTS:
+        return JSONResponse(status_code=400, content={"error": f"Unknown model: {model_name}"})
+    raw = await file.read()
+    pil = Image.open(io.BytesIO(raw)).convert("L")
+    t = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3),
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+    ])
+    tensor = t(pil).unsqueeze(0).to(device)
+    clf = get_classifier(model_name)
+    with torch.no_grad():
+        prob = torch.softmax(clf(tensor), dim=1).cpu().numpy()[0]
+    idx = int(np.argmax(prob))
+    return {
+        "model": model_name,
+        "prediction": "Normal" if idx == 0 else "Pneumonia",
+        "confidence": float(prob[idx]),
+        "prob_normal": float(prob[0]),
+        "prob_pneumonia": float(prob[1]),
+    }

gui/frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

gui/frontend/dist/assets/index-_A223EyE.css

@@ -0,0 +1 @@
+@import "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap";*,:before,:after{box-sizing:border-box}body{margin:0}:root{--bg:#060b17;--surface:#0d1526;--surface2:#111d35;--border:#4f8ef726;--blue:#4f8ef7;--purple:#a855f7;--green:#22c55e;--red:#ef4444;--text:#e2e8f0;--muted:#64748b;--radius:14px}*,:before,:after{box-sizing:border-box;margin:0;padding:0}html{scroll-behavior:smooth}body{background:var(--bg);color:var(--text);-webkit-font-smoothing:antialiased;min-height:100vh;font-family:Inter,sans-serif}.hero{text-align:center;border-bottom:1px solid var(--border);padding:64px 24px 56px;position:relative;overflow:hidden}.hero-glow{pointer-events:none;background:radial-gradient(80% 60% at 50% -20%,#4f8ef72e 0%,#0000 70%);position:absolute;inset:0}.hero-badge{letter-spacing:.1em;text-transform:uppercase;color:var(--blue);background:#4f8ef714;border:1px solid #4f8ef759;border-radius:99px;margin-bottom:20px;padding:4px 14px;font-size:11px;font-weight:600;display:inline-block}.hero h1{color:#fff;margin-bottom:16px;font-size:clamp(28px,5vw,52px);font-weight:800;line-height:1.15}.gradient-text{background:linear-gradient(135deg, var(--blue), var(--purple));-webkit-text-fill-color:transparent;-webkit-background-clip:text;background-clip:text}.hero-sub{color:var(--muted);letter-spacing:.04em;font-size:14px}.main{flex-direction:column;gap:28px;max-width:1100px;margin:0 auto;padding:40px 24px 80px;display:flex}.card{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);padding:28px;transition:border-color .2s}.card:hover{border-color:#4f8ef74d}.card-header{align-items:center;gap:12px;margin-bottom:20px;display:flex}.card-header h2{color:#fff;font-size:18px;font-weight:700}.card-desc{color:var(--muted);margin-bottom:20px;font-size:13px;line-height:1.6}.badge{letter-spacing:.06em;text-transform:uppercase;color:var(--blue);white-space:nowrap;background:#4f8ef71f;border:1px solid #4f8ef740;border-radius:99px;padding:3px 10px;font-size:11px;font-weight:600}.upload-zone{text-align:center;cursor:pointer;background:#4f8ef70a;border:2px dashed #4f8ef759;border-radius:12px;padding:48px 24px;transition:all .25s}.upload-zone:hover,.upload-zone.dragging{border-color:var(--blue);background:#4f8ef717;transform:scale(1.005)}.upload-zone.has-preview{padding:16px}.upload-icon{margin-bottom:12px;font-size:48px}.upload-title{color:#fff;margin-bottom:6px;font-size:16px;font-weight:600}.upload-sub{color:var(--muted);font-size:13px}.preview-wrap{display:inline-block;position:relative}.preview-img{border-radius:8px;max-height:220px;margin:0 auto;display:block}.preview-change{color:#fff;opacity:0;background:#0000008c;border-radius:0 0 8px 8px;padding:6px;font-size:12px;transition:opacity .2s;position:absolute;bottom:0;left:0;right:0}.preview-wrap:hover .preview-change{opacity:1}.img-grid{grid-template-columns:repeat(auto-fill,minmax(160px,1fr));gap:14px;display:grid}.img-card{background:var(--surface2);border:1px solid var(--border);border-radius:10px;transition:transform .2s,border-color .2s;overflow:hidden}.img-card:hover{border-color:#4f8ef766;transform:translateY(-3px)}.img-card img{aspect-ratio:1;object-fit:cover;width:100%;display:block}.img-label{color:var(--muted);text-align:center;padding:6px 4px;font-size:11px;font-weight:500;display:block}.gen-all-grid{grid-template-columns:repeat(3,1fr);gap:16px;margin-top:24px;display:grid}.model-col{background:var(--surface2);border:1px solid var(--border);border-radius:12px;transition:border-color .2s,transform .2s;overflow:hidden}.model-col:hover{transform:translateY(-2px)}.model-col-header{border-left:3px solid;border-bottom:1px solid var(--border);background:#ffffff05;padding:12px 14px}.model-name{letter-spacing:.05em;text-transform:uppercase;margin-bottom:3px;font-size:13px;font-weight:700;display:block}.model-desc{color:var(--muted);font-size:10px;line-height:1.4;display:block}.model-img-stack{flex-direction:column;gap:8px;padding:10px;display:flex}.img-placeholder{aspect-ratio:1;background:#ffffff0a;border:1px dashed #ffffff14;border-radius:8px;width:100%}.gen-badge{color:#10b981!important;background:#10b9811f!important;border-color:#10b9814d!important}.spinner-label{color:var(--muted);text-align:center;margin-top:10px;font-size:12px}@media (width<=900px){.gen-all-grid{grid-template-columns:repeat(2,1fr)}}@media (width<=580px){.gen-all-grid{grid-template-columns:1fr}}.btn-primary{background:linear-gradient(135deg, var(--blue), var(--purple));color:#fff;cursor:pointer;border:none;border-radius:10px;padding:11px 24px;font-family:inherit;font-size:14px;font-weight:600;transition:opacity .2s,transform .15s}.btn-primary:hover:not(:disabled){opacity:.88;transform:translateY(-1px)}.btn-primary:disabled{opacity:.45;cursor:not-allowed}.clf-controls{flex-wrap:wrap;align-items:center;gap:12px;display:flex}.select-wrap select{background:var(--surface2);color:var(--text);border:1px solid var(--border);cursor:pointer;border-radius:10px;outline:none;min-width:150px;padding:10px 16px;font-family:inherit;font-size:14px;transition:border-color .2s}.select-wrap select:focus{border-color:var(--blue)}.result-box{border:1px solid;border-radius:12px;margin-top:20px;padding:20px}.result-box.normal{background:#22c55e0f;border-color:#22c55e59}.result-box.pneumonia{background:#ef44440f;border-color:#ef444459}.result-header{align-items:center;gap:14px;margin-bottom:16px;display:flex}.result-icon{font-size:28px}.result-label{color:var(--muted);text-transform:uppercase;letter-spacing:.08em;font-size:11px}.result-pred{color:#fff;font-size:22px;font-weight:800}.result-model-badge{color:var(--blue);background:#4f8ef71f;border:1px solid #4f8ef740;border-radius:99px;margin-left:auto;padding:4px 12px;font-size:11px;font-weight:600}.conf-bars{flex-direction:column;gap:10px;display:flex}.conf-row{align-items:center;gap:10px;display:flex}.conf-label{width:80px;color:var(--muted);font-size:13px;font-weight:500}.conf-track{background:#ffffff14;border-radius:99px;flex:1;height:8px;overflow:hidden}.conf-fill{border-radius:99px;height:100%;transition:width .6s cubic-bezier(.4,0,.2,1)}.conf-pct{text-align:right;width:48px;color:var(--text);font-size:13px;font-weight:600}.table-wrap{overflow-x:auto}.results-table{border-collapse:collapse;width:100%;font-size:13px}.results-table th{text-align:left;text-transform:uppercase;letter-spacing:.07em;color:var(--muted);border-bottom:1px solid var(--border);padding:10px 14px;font-size:11px;font-weight:600}.results-table td{border-bottom:1px solid #ffffff0a;padding:12px 14px}.results-table tr:last-child td{border-bottom:none}.results-table tr:hover td{background:#4f8ef70d}.row-best td{background:#4f8ef712}.row-best td:first-child{border-left:3px solid var(--blue)}.cell-best,.cell-fp-low{color:#22d3a5;font-weight:700}.cell-worst{color:#f87171;font-weight:600}.table-model-name{align-items:center;gap:8px;display:flex}.table-dot{border-radius:50%;flex-shrink:0;width:8px;height:8px}.trophy{color:var(--blue);background:linear-gradient(135deg,#4f8ef733,#a855f733);border:1px solid #4f8ef766;border-radius:99px;margin-left:4px;padding:2px 8px;font-size:11px;font-weight:700}.spinner-wrap{justify-content:center;padding:32px;display:flex}.spinner{border:3px solid #4f8ef733;border-top-color:var(--blue);border-radius:50%;width:36px;height:36px;animation:.75s linear infinite spin}@keyframes spin{to{transform:rotate(360deg)}}.empty{color:var(--muted);text-align:center;padding:32px 0;font-size:13px}.footer{border-top:1px solid var(--border);text-align:center;color:var(--muted);padding:20px;font-size:12px}@media (width<=640px){.gen-grid{grid-template-columns:1fr}.gen-divider{display:none}.clf-controls{flex-direction:column;align-items:stretch}}

gui/frontend/dist/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>CVPR — Generative Medical Imaging Augmentation</title>
+    <meta name="description" content="Interactive dashboard for generative medical imaging augmentation using GAN, EBM, Diffusion, DiT, MaskGIT, and VAE on PneumoniaMNIST." />
+    <script type="module" crossorigin src="/assets/index-B4BfuFGE.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-_A223EyE.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

gui/frontend/eslint.config.js

@@ -0,0 +1,21 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      globals: globals.browser,
+      parserOptions: { ecmaFeatures: { jsx: true } },
+    },
+  },
+])

gui/frontend/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>CVPR — Generative Medical Imaging Augmentation</title>
+    <meta name="description" content="Interactive dashboard for generative medical imaging augmentation using GAN, EBM, Diffusion, DiT, MaskGIT, and VAE on PneumoniaMNIST." />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

gui/frontend/node_modules/.bin/acorn

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../acorn/bin/acorn" "$@"
+else 
+  exec node  "$basedir/../acorn/bin/acorn" "$@"
+fi

gui/frontend/node_modules/.bin/acorn.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\acorn\bin\acorn" %*

gui/frontend/node_modules/.bin/acorn.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../acorn/bin/acorn" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../acorn/bin/acorn" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../acorn/bin/acorn" $args
+  } else {
+    & "node$exe"  "$basedir/../acorn/bin/acorn" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/baseline-browser-mapping

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../baseline-browser-mapping/dist/cli.cjs" "$@"
+else 
+  exec node  "$basedir/../baseline-browser-mapping/dist/cli.cjs" "$@"
+fi

gui/frontend/node_modules/.bin/baseline-browser-mapping.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\baseline-browser-mapping\dist\cli.cjs" %*

gui/frontend/node_modules/.bin/baseline-browser-mapping.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../baseline-browser-mapping/dist/cli.cjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../baseline-browser-mapping/dist/cli.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../baseline-browser-mapping/dist/cli.cjs" $args
+  } else {
+    & "node$exe"  "$basedir/../baseline-browser-mapping/dist/cli.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/browserslist

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../browserslist/cli.js" "$@"
+else 
+  exec node  "$basedir/../browserslist/cli.js" "$@"
+fi

gui/frontend/node_modules/.bin/browserslist.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\browserslist\cli.js" %*

gui/frontend/node_modules/.bin/browserslist.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../browserslist/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../browserslist/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../browserslist/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../browserslist/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/eslint

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../eslint/bin/eslint.js" "$@"
+else 
+  exec node  "$basedir/../eslint/bin/eslint.js" "$@"
+fi

gui/frontend/node_modules/.bin/eslint.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\eslint\bin\eslint.js" %*

gui/frontend/node_modules/.bin/eslint.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../eslint/bin/eslint.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../eslint/bin/eslint.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../eslint/bin/eslint.js" $args
+  } else {
+    & "node$exe"  "$basedir/../eslint/bin/eslint.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/jsesc

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../jsesc/bin/jsesc" "$@"
+else 
+  exec node  "$basedir/../jsesc/bin/jsesc" "$@"
+fi

gui/frontend/node_modules/.bin/jsesc.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\jsesc\bin\jsesc" %*

gui/frontend/node_modules/.bin/jsesc.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  } else {
+    & "node$exe"  "$basedir/../jsesc/bin/jsesc" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/json5

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../json5/lib/cli.js" "$@"
+else 
+  exec node  "$basedir/../json5/lib/cli.js" "$@"
+fi

gui/frontend/node_modules/.bin/json5.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\json5\lib\cli.js" %*

gui/frontend/node_modules/.bin/json5.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../json5/lib/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../json5/lib/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../json5/lib/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../json5/lib/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/nanoid

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
+else 
+  exec node  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
+fi

gui/frontend/node_modules/.bin/nanoid.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\nanoid\bin\nanoid.cjs" %*

gui/frontend/node_modules/.bin/nanoid.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  } else {
+    & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

gui/frontend/node_modules/.bin/node-which

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../which/bin/node-which" "$@"
+else 
+  exec node  "$basedir/../which/bin/node-which" "$@"
+fi

gui/frontend/node_modules/.bin/node-which.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\which\bin\node-which" %*

gui/frontend/node_modules/.bin/node-which.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../which/bin/node-which" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../which/bin/node-which" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../which/bin/node-which" $args
+  } else {
+    & "node$exe"  "$basedir/../which/bin/node-which" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret