Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* 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
+Evaluation[[:space:]]Results/Eval[[:space:]]1.png filter=lfs diff=lfs merge=lfs -text
+Evaluation[[:space:]]Results/Eval[[:space:]]2.png filter=lfs diff=lfs merge=lfs -text
+Testing[[:space:]]Results/Result[[:space:]]of[[:space:]]Test[[:space:]]1.png filter=lfs diff=lfs merge=lfs -text
+Testing[[:space:]]Results/Result[[:space:]]of[[:space:]]Test[[:space:]]2.png filter=lfs diff=lfs merge=lfs -text
+Testing[[:space:]]Results/Result[[:space:]]of[[:space:]]Test[[:space:]]3.png filter=lfs diff=lfs merge=lfs -text

Evaluation Results/desktop.ini

@@ -0,0 +1,3 @@
+[LocalizedFileNames]
+Screenshot 2026-03-30 001932.png=@Screenshot 2026-03-30 001932,0
+Screenshot 2026-03-29 120202.png=@Screenshot 2026-03-29 120202,0

README.md

@@ -1,11 +1,27 @@
----
-license: mit
-language:
-- en
-tags:
-- autoencoder
-- compressor
-datasets:
-- flwrlabs/celeba
-pipeline_tag: image-to-image
----
+
+# CelebA Autoencoder
+
+## Overview
+This project implements a **Convolutional Autoencoder** trained on the [*CelebA dataset*](https://www.kaggle.com/datasets/jessicali9530/celeba-dataset) for image compression and reconstruction.
+
+## Features
+- Learns compressed latent representation of face images
+- Reconstructs images from compressed representation
+- Evaluated using PSNR and SSIM metrics
+
+## Dataset
+- [CelebA Dataset (Kaggle)](https://www.kaggle.com/datasets/jessicali9530/celeba-dataset)
+
+## Model
+- Encoder: Convolutional layers with downsampling
+- Decoder: Transposed convolution layers for reconstruction
+
+## Results
+- Average PSNR: 31.126471439997356
+- Average SSIM: 0.9329655667146047
+
+# Notes
+- Model performs lossy compression
+- Some blurring is expected due to reconstruction loss
+
+# Please Fell Free to Use this Project in what ever way you like.

Testing Results/desktop.ini

@@ -0,0 +1,4 @@
+[LocalizedFileNames]
+Screenshot 2026-03-30 002049.png=@Screenshot 2026-03-30 002049,0
+Screenshot 2026-03-30 002744.png=@Screenshot 2026-03-30 002744,0
+Screenshot 2026-03-30 003604.png=@Screenshot 2026-03-30 003604,0

autoencoder_celeba.pth

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

autoencoder_on_image_compression.py

@@ -0,0 +1,437 @@
+# -*- coding: utf-8 -*-
+"""Autoencoder on Image Compression.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/13X8ZS11V0GCWpowuJZ3igEYJa6kRx9DL
+"""
+
+from google.colab import files
+files.upload()
+
+import os
+
+os.makedirs('/root/.kaggle', exist_ok=True)
+!cp kaggle.json /root/.kaggle/
+!chmod 600 /root/.kaggle/kaggle.json
+
+!kaggle datasets download -d jessicali9530/celeba-dataset
+!unzip -q celeba-dataset.zip
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import transforms
+from torch.utils.data import Dataset, DataLoader, random_split
+
+from torch.amp import autocast, GradScaler
+
+class CelebADataset(Dataset):
+    def __init__(self, img_dir, transform=None):
+        self.img_dir = img_dir
+        self.image_names = sorted(os.listdir(img_dir))
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.image_names)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.img_dir, self.image_names[idx])
+        image = Image.open(img_path).convert('RGB')
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image
+
+transform = transforms.Compose([
+    transforms.Resize((128, 128)),
+    transforms.ToTensor()
+])
+
+dataset = CelebADataset("img_align_celeba/img_align_celeba", transform=transform)
+
+dataset.image_names = dataset.image_names[:60000]
+
+train_size = int(0.8 * len(dataset))
+val_size = len(dataset) - train_size
+
+train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
+
+train_loader = DataLoader(
+    train_dataset,
+    batch_size=512,
+    shuffle=True,
+    num_workers=2,
+    pin_memory=True,
+    persistent_workers=False
+)
+
+val_loader = DataLoader(
+    val_dataset,
+    batch_size=512,
+    shuffle=False,
+    num_workers=2,
+    pin_memory=True,
+    persistent_workers=False
+)
+
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super(Autoencoder, self).__init__()
+
+        self.encoder = nn.Sequential(
+            nn.Conv2d(3, 64, 4, 2, 1),
+            nn.ReLU(),
+            nn.Conv2d(64, 128, 4, 2, 1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.Conv2d(128, 256, 4, 2, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Conv2d(256, 512, 4, 2, 1),
+            nn.ReLU()
+        )
+
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose2d(512, 256, 4, 2, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.ConvTranspose2d(256, 128, 4, 2, 1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.ConvTranspose2d(128, 64, 4, 2, 1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(64, 3, 4, 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.decoder(self.encoder(x))
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = Autoencoder().to(device).to(memory_format=torch.channels_last)
+
+model = torch.compile(model)
+
+criterion = nn.L1Loss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+scaler = GradScaler()
+
+torch.backends.cudnn.benchmark = True
+
+epochs = 50
+
+for epoch in range(epochs):
+    model.train()
+    train_loss = 0
+
+    for images in train_loader:
+        images = images.to(device, non_blocking=True).to(memory_format=torch.channels_last)
+
+        optimizer.zero_grad()
+
+        with autocast(device_type='cuda'):
+            outputs = model(images)
+            loss = criterion(outputs, images)
+
+        scaler.scale(loss).backward()
+        scaler.step(optimizer)
+        scaler.update()
+
+        train_loss += loss.item()
+
+    train_loss /= len(train_loader)
+
+    model.eval()
+    val_loss = 0
+
+    with torch.no_grad():
+        for images in val_loader:
+            images = images.to(device, non_blocking=True).to(memory_format=torch.channels_last)
+
+            with autocast(device_type='cuda'):
+                outputs = model(images)
+                loss = criterion(outputs, images)
+
+            val_loss += loss.item()
+
+    val_loss /= len(val_loader)
+
+    print(f"Epoch [{epoch+1}/{epochs}] | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f}")
+
+dataiter = iter(val_loader)
+images = next(dataiter).to(device)
+
+with torch.no_grad():
+    outputs = model(images)
+
+images = images.cpu().numpy()
+outputs = outputs.cpu().numpy()
+
+fig, axes = plt.subplots(2, 6, figsize=(12,4))
+
+for i in range(6):
+    axes[0, i].imshow(np.transpose(images[i], (1,2,0)))
+    axes[0, i].axis('off')
+
+    axes[1, i].imshow(np.transpose(outputs[i], (1,2,0)))
+    axes[1, i].axis('off')
+
+plt.show()
+
+!pip install pytorch-msssim
+
+loss = criterion(outputs, images)
+
+import torch
+
+def calculate_psnr(original, reconstructed):
+    mse = torch.mean((original - reconstructed) ** 2)
+    if mse == 0:
+        return 100
+    psnr = 20 * torch.log10(1.0 / torch.sqrt(mse))
+    return psnr
+
+from pytorch_msssim import ssim
+
+model.eval()
+
+total_psnr = 0
+total_ssim = 0
+count = 0
+
+with torch.no_grad():
+    for images in val_loader:
+        images = images.to(device)
+        outputs = model(images)
+
+        total_psnr += calculate_psnr(images, outputs).item()
+        total_ssim += ssim(images, outputs, data_range=1.0, size_average=True).item()
+        count += 1
+
+print("Average PSNR:", total_psnr / count)
+print("Average SSIM:", total_ssim / count)
+
+from google.colab import files
+uploaded = files.upload()
+
+from PIL import Image
+
+img_path = list(uploaded.keys())[0]
+
+image = Image.open(img_path).convert('RGB')
+
+transform = transforms.Compose([
+    transforms.Resize((128, 128)),
+    transforms.ToTensor()
+])
+
+input_image = transform(image).unsqueeze(0).to(device)
+
+model.eval()
+
+with torch.no_grad():
+    output_image = model(input_image)
+
+input_np = input_image.squeeze().cpu().numpy()
+output_np = output_image.squeeze().cpu().numpy()
+
+import matplotlib.pyplot as plt
+
+fig, axes = plt.subplots(1, 2, figsize=(8,4))
+
+axes[0].imshow(input_np.transpose(1,2,0))
+axes[0].set_title("Original")
+axes[0].axis('off')
+
+axes[1].imshow(output_np.transpose(1,2,0))
+axes[1].set_title("Reconstructed")
+axes[1].axis('off')
+
+plt.show()
+
+torch.save(model.state_dict(), "autoencoder_celeba.pth")
+
+torch.save(model, "autoencoder_full.pth")
+
+from google.colab import files
+files.download("autoencoder_celeba.pth")
+
+state_dict = torch.load("autoencoder_celeba.pth")
+
+new_state_dict = {}
+for k, v in state_dict.items():
+    new_key = k.replace("_orig_mod.", "")
+    new_state_dict[new_key] = v
+
+model = Autoencoder().to(device)
+model.load_state_dict(new_state_dict)
+model.eval()
+
+model.load_state_dict(torch.load("autoencoder_celeba.pth"), strict=False)
+
+import os
+
+project_dir = "celeba-autoencoder"
+os.makedirs(project_dir, exist_ok=True)
+
+model_code = """
+import torch
+import torch.nn as nn
+
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super(Autoencoder, self).__init__()
+
+        self.encoder = nn.Sequential(
+            nn.Conv2d(3, 64, 4, 2, 1),
+            nn.ReLU(),
+            nn.Conv2d(64, 128, 4, 2, 1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.Conv2d(128, 256, 4, 2, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Conv2d(256, 512, 4, 2, 1),
+            nn.ReLU()
+        )
+
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose2d(512, 256, 4, 2, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.ConvTranspose2d(256, 128, 4, 2, 1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.ConvTranspose2d(128, 64, 4, 2, 1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(64, 3, 4, 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.decoder(self.encoder(x))
+"""
+
+with open(f"{project_dir}/model.py", "w") as f:
+    f.write(model_code)
+
+inference_code = """
+import torch
+from torchvision import transforms
+from PIL import Image
+import matplotlib.pyplot as plt
+import sys
+
+from model import Autoencoder
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = Autoencoder().to(device)
+
+state_dict = torch.load("autoencoder_celeba.pth", map_location=device)
+
+# Fix for torch.compile prefix
+new_state_dict = {k.replace("_orig_mod.", ""): v for k, v in state_dict.items()}
+
+model.load_state_dict(new_state_dict)
+model.eval()
+
+image_path = sys.argv[1]
+
+transform = transforms.Compose([
+    transforms.Resize((128, 128)),
+    transforms.ToTensor()
+])
+
+image = Image.open(image_path).convert("RGB")
+input_tensor = transform(image).unsqueeze(0).to(device)
+
+with torch.no_grad():
+    output = model(input_tensor)
+
+input_np = input_tensor.squeeze().cpu().numpy()
+output_np = output.squeeze().cpu().numpy()
+
+fig, axes = plt.subplots(1, 2, figsize=(8,4))
+
+axes[0].imshow(input_np.transpose(1,2,0))
+axes[0].set_title("Original")
+axes[0].axis("off")
+
+axes[1].imshow(output_np.transpose(1,2,0))
+axes[1].set_title("Reconstructed")
+axes[1].axis("off")
+
+plt.show()
+"""
+
+with open(f"{project_dir}/inference.py", "w") as f:
+    f.write(inference_code)
+
+requirements = """torch
+torchvision
+pillow
+matplotlib
+pytorch-msssim
+"""
+
+with open(f"{project_dir}/requirements.txt", "w") as f:
+    f.write(requirements)
+
+readme = """
+# CelebA Autoencoder
+
+## Overview
+This project implements a Convolutional Autoencoder trained on the CelebA dataset for image compression and reconstruction.
+
+## Features
+- Learns compressed latent representation of face images
+- Reconstructs images from compressed representation
+- Evaluated using PSNR and SSIM metrics
+
+## Dataset
+- CelebA Dataset (Kaggle)
+
+## Model
+- Encoder: Convolutional layers with downsampling
+- Decoder: Transposed convolution layers for reconstruction
+
+## Results
+- PSNR: ~31 dB
+- SSIM: ~0.93
+
+## Usage
+
+### Run Inference
+```bash
+python inference.py path_to_image.jpg
+
+Notes
+Model performs lossy compression
+Some blurring is expected due to reconstruction loss
+Author
+
+Autoencoder project for Deep Learning experiment
+"""
+
+with open(f"{project_dir}/README.md", "w") as f:
+  f.write(readme)
+
+import shutil
+
+shutil.copy("autoencoder_celeba.pth", f"{project_dir}/autoencoder_celeba.pth")
+
+shutil.make_archive("celeba-autoencoder", 'zip', project_dir)
+
+from google.colab import files
+files.download("celeba-autoencoder.zip")

inference.py

@@ -0,0 +1,48 @@
+
+import torch
+from torchvision import transforms
+from PIL import Image
+import matplotlib.pyplot as plt
+import sys
+
+from model import Autoencoder
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = Autoencoder().to(device)
+
+state_dict = torch.load("autoencoder_celeba.pth", map_location=device)
+
+# Fix for torch.compile prefix
+new_state_dict = {k.replace("_orig_mod.", ""): v for k, v in state_dict.items()}
+
+model.load_state_dict(new_state_dict)
+model.eval()
+
+image_path = sys.argv[1]
+
+transform = transforms.Compose([
+    transforms.Resize((128, 128)),
+    transforms.ToTensor()
+])
+
+image = Image.open(image_path).convert("RGB")
+input_tensor = transform(image).unsqueeze(0).to(device)
+
+with torch.no_grad():
+    output = model(input_tensor)
+
+input_np = input_tensor.squeeze().cpu().numpy()
+output_np = output.squeeze().cpu().numpy()
+
+fig, axes = plt.subplots(1, 2, figsize=(8,4))
+
+axes[0].imshow(input_np.transpose(1,2,0))
+axes[0].set_title("Original")
+axes[0].axis("off")
+
+axes[1].imshow(output_np.transpose(1,2,0))
+axes[1].set_title("Reconstructed")
+axes[1].axis("off")
+
+plt.show()

model.py

@@ -0,0 +1,36 @@
+
+import torch
+import torch.nn as nn
+
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super(Autoencoder, self).__init__()
+
+        self.encoder = nn.Sequential(
+            nn.Conv2d(3, 64, 4, 2, 1),
+            nn.ReLU(),
+            nn.Conv2d(64, 128, 4, 2, 1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.Conv2d(128, 256, 4, 2, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Conv2d(256, 512, 4, 2, 1),
+            nn.ReLU()
+        )
+
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose2d(512, 256, 4, 2, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.ConvTranspose2d(256, 128, 4, 2, 1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.ConvTranspose2d(128, 64, 4, 2, 1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(64, 3, 4, 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.decoder(self.encoder(x))

requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+pillow
+matplotlib
+pytorch-msssim