Model Card: StyleGAN Model (128x128 Faces)
Model Details
- Model Type: Generative Adversarial Network (GAN)
- Architecture: Custom StyleGAN-inspired variant (Pure PyTorch implementation)
- Resolution: 128x128 (Inferred based on visual frequency outputs)
- Parameters: 19M
- Training Hardware: Kaggle (Single GPU - P100)
- License: cc-by-sa-4.0
Model Description
This is a custom, from-scratch implementation of a StyleGAN-like architecture built entirely in native PyTorch. It strictly avoids NVIDIA's dnnlib and custom CUDA kernels (such as fused upsample/downsample and upfirdn2d filters).
The primary objective of this model is to serve as a compute-constrained proof-of-concept. It demonstrates that the global manifold of human faces can be successfully mapped using standard PyTorch operations on limited hardware (Kaggle free-tier GPUs), accepting the inherent trade-offs in memory overhead and operational latency.
Out-of-Scope Uses
- High-Fidelity Generation: This model lacks the capacity to resolve high-frequency spatial details (skin texture, fine hair, sharp ocular reflections).
- Production Environments: The reliance on unoptimized PyTorch operations makes inference slower and more memory-intensive compared to standard compiled StyleGAN models.
Limitations and Artifacts
Due to the architectural and computational constraints, users should expect specific structural anomalies:
- Resolution Ceiling: The output is bottlenecked at a low resolution, resulting in a smoothed, blurry appearance.
- Geometric Instability: At the edges of the learned distribution, the model struggles with background separation and asymmetrical feature alignment (e.g., glasses melting into skin, uneven eye placement).
- Truncation Requirement: To generate structurally coherent faces, a truncation trick factor of approximately $\psi = 0.7$ is required. Sampling from the unconstrained prior will likely yield severe artifacts.
Training Data
- Dataset: [FFHQ downsampled]
- Note on Bias: Generative face models inherit the demographic biases present in their training data. Users should expect over-representation of specific ethnicities, ages, and lighting conditions based on the underlying dataset distribution.
How to Use (Code Snippet)
Because this repository contains a raw PyTorch .pt state dictionary rather than a Hugging Face compatible class, you must define the network architecture locally before loading the weights.
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
# 1. Define the exact Generator architecture used during training
class CustomStyleGANGenerator(nn.Module):
def __init__(self):
super().__init__()
# [USER MUST PASTE THE GENERATOR CLASS CODE HERE]
pass
def forward(self, z):
# [USER MUST PASTE THE FORWARD PASS HERE]
pass
# 2. Download and load the weights
repo_id = "Pradeep016/StyleGAN-FFHQ"
filename = "styleGAN_Model.pt"
weights_path = hf_hub_download(repo_id=repo_id, filename=filename)
# 3. Instantiate and load
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
generator = CustomStyleGANGenerator().to(device)
generator.load_state_dict(torch.load(weights_path, map_location=device))
generator.eval()
# 4. Generate a sample (example using latent dim of 512)
with torch.no_grad():
z = torch.randn(1, 512).to(device)
# Apply truncation psi=0.7 manually if required by your implementation
output_image = generator(z)
