Hugging Face's logo

Supernova11c
/
Supernova-Creation-TeraiLLM-V3

Text-to-Image
Nepali
Supernova
image generation
Model card Files
xet
 Community

Supernova Creation TeraiLLM V3

A from-scratch 128Γ—128 image generation model by Supernova11c.

Supernova Creation TeraiLLM V3 is Supernova's first image generation model designed to produce images from a learned latent representation rather than relying on a pretrained image-generation backbone.

V3 was built from scratch using PyTorch and trained on real images. It uses a compact 128-dimensional latent space, residual blocks, convolutional encoding/decoding, and a lightweight probabilistic latent representation.

The result is a model that can:

  • Generate new images from random latent vectors
  • Reconstruct previously unseen images
  • Learn broad image structure and composition
  • Encode images into a 128-dimensional latent representation
  • Decode latent representations back into images
  • Run without a text prompt or external text encoder
  • Run on CPU or CUDA-compatible hardware
  • Be downloaded and executed directly by other users

What makes V3 special?

Supernova Creation V3 is intentionally built from scratch.

It does not depend on:

  • Stable Diffusion
  • A pretrained image-generation backbone
  • A pretrained vision encoder
  • A pretrained decoder
  • GAN training
  • A pretrained text encoder

The model learns its visual representation directly from the training images.

This makes V3 an important milestone for Supernova: our first image-generation system that produces working visual output rather than being only an architectural prototype.

V3 is not intended to compete directly with large text-to-image systems in scale or prompt understanding. Its strength is different: a relatively compact architecture learns meaningful visual representations and can generate and reconstruct images using a small latent space.

Architecture

V3 uses the following architecture:

Input Image β”‚ β–Ό 3-channel convolution β”‚ β–Ό 64 channels β”‚ β–Ό 128 channels β”‚ β–Ό 256 channels β”‚ β–Ό 512 channels β”‚ β–Ό 8 Γ— 8 Γ— 512 feature representation β”‚ β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β–Ί ΞΌ β”‚ └──────────────► log variance β”‚ β–Ό 128-dimensional latent space β”‚ β–Ό Linear decoder β”‚ β–Ό 8 Γ— 8 Γ— 512 β”‚ β–Ό Residual blocks β”‚ β–Ό 128 Γ— 128 Γ— 3 β”‚ β–Ό RGB image

Core configuration

Property| V3 Image resolution| 128 Γ— 128 Input channels| 3 Latent dimension| 128 Base channels| 64 Bottleneck| 8 Γ— 8 Γ— 512 Parameters| 30,676,611 Output| RGB Main activation| SiLU Normalization| GroupNorm Residual blocks| Yes Text conditioning| No Prompt generation| No CUDA support| Yes CPU inference| Yes

Latent Representation

V3 compresses an image into a 128-dimensional latent representation.

The encoder produces:

Image β†’ Encoder β†’ ΞΌ + logvar β†’ 128-dimensional latent

The decoder performs:

128-dimensional latent β†’ Decoder β†’ 128Γ—128 RGB image

This latent representation allows V3 to perform both reconstruction and completely new generation.

For random generation, a latent vector can be sampled and passed directly through the decoder.

Image Generation

V3 can generate an image without being given an input image.

A random 128-dimensional latent vector is sampled:

Random latent ↓ 128-dimensional vector ↓ V3 decoder ↓ 128Γ—128 RGB image

This means the model has learned a visual distribution from its training data rather than simply storing a single image-to-image transformation.

Image Reconstruction

V3 can also reconstruct an image.

For deterministic reconstruction, V3 encodes the image and uses the learned mean latent representation:

Input image ↓ Encoder ↓ ΞΌ ↓ Decoder ↓ Reconstructed image

This is also how the unseen-test evaluation is performed.

BHI-2000 Training

The official V3 checkpoint was trained using 2,000 selected images from the BHI Mini dataset.

The data split was:

4,500 available images β”‚ β–Ό 2,000 selected with seed 20261003 β”‚ β”œβ”€β”€ 1,800 training images β”‚ └── 200 completely unseen test images

The training and test sets were kept disjoint.

Images were converted to RGB and resized to 128Γ—128 while preserving the complete image using LANCZOS resampling.

Training configuration

Epochs : 200 Batch size : 16 Learning rate : 0.0002 Optimizer : AdamW Weight decay : 0.0001 KL coefficient : 0.001 Gradient clip : 1.0 Seed : 20261003

Unseen Test Results

V3 was evaluated on 200 images that were not used for training.

The deterministic reconstruction results were:

Metric| Result MAE| 0.068876 MSE| 0.010961 RMSE| 0.104694

These are pixel-level reconstruction metrics calculated at 128Γ—128 resolution.

The test set was completely separated from the training set.

V3 Development Milestones

Supernova Creation V3 was developed through several stages.

Wikimedia image test

The initial V3 implementation was tested using automatically discovered Wikimedia Commons images.

This established the complete 128Γ—128 training and generation pipeline:

Image discovery ↓ Image preprocessing ↓ V3 training ↓ Latent representation ↓ Reconstruction ↓ Random generation

Seven-image visual learning

V3 was subsequently trained on a seven-image street collection to examine how strongly the architecture could learn visual structure from a very small dataset.

The reconstruction result was:

MAE : 0.041101 MSE : 0.004684

This demonstrates strong reconstruction of that small training collection, although it should not be interpreted as a generalization benchmark.

BHI-2000

The BHI-2000 run became the main V3 model.

It expanded training to 1,800 images and reserved 200 completely unseen images for evaluation.

This provides a substantially more meaningful measure of how the architecture behaves beyond the images it directly trained on.

What V3 Can Do

  1. Generate

Generate a new 128Γ—128 image from a random latent vector.

  1. Reconstruct

Encode an image and decode its learned latent representation.

  1. Encode

Convert an image into a compact 128-dimensional representation.

  1. Decode

Convert a 128-dimensional latent vector into an RGB image.

  1. CPU inference

The architecture can be loaded for CPU inference without requiring a CUDA GPU.

  1. CUDA inference

If CUDA is available, PyTorch can use the GPU automatically.

  1. Reproducible evaluation

The BHI-2000 selection and evaluation process uses a fixed seed and deterministic train/test separation.

What V3 Does Not Do

V3 is currently not a text-to-image model.

It does not understand prompts such as:

"a mountain under a blue sky"

because there is currently no text encoder or text-conditioning pathway.

Generation is latent-based:

128-dimensional latent β†’ image

rather than:

text prompt β†’ text encoder β†’ image

Text conditioning is a possible direction for future Supernova image-generation systems.

Quick Start

  1. Clone or download this repository

Download the repository files and place them in the same directory.

The most important files are:

model.py configuration.py interface.py generate.py reconstruct.py supernova_creation_v3_bhi2000.pt

  1. Install dependencies

pip install torch numpy Pillow

  1. Generate an image

python generate.py --checkpoint supernova_creation_v3_bhi2000.pt

The generated image will be saved as:

supernova_v3_generated.png

For a reproducible generation:

python generate.py
--checkpoint supernova_creation_v3_bhi2000.pt
--seed 20261003

Python API

After downloading the repository:

from interface import SupernovaCreationV3Interface

model = SupernovaCreationV3Interface( "supernova_creation_v3_bhi2000.pt" )

image = model.generate( seed=20261003 )

model.save_image( image, "generated.png" )

Reconstruct an Image

from interface import SupernovaCreationV3Interface

model = SupernovaCreationV3Interface( "supernova_creation_v3_bhi2000.pt" )

reconstruction = model.reconstruct( "input.png" )

model.save_image( reconstruction, "reconstruction.png" )

Direct CPU Usage

V3 can explicitly be loaded on CPU:

from interface import SupernovaCreationV3Interface

model = SupernovaCreationV3Interface( "supernova_creation_v3_bhi2000.pt", device="cpu" )

image = model.generate()

model.save_image( image, "cpu_generated.png" )

Model Files

supernova_creation_v3_bhi2000.pt

The official trained V3 weights.

model.py

The exact V3 neural-network architecture.

configuration.py

The canonical V3 configuration.

interface.py

Simple Python interface for loading, generating, encoding, decoding, and reconstructing images.

generate.py

Command-line random image generation.

reconstruct.py

Command-line image reconstruction.

evaluate.py

BHI-2000 unseen-test evaluation.

train_bhi2000.py

Training implementation for reproducing the BHI-2000 model.

v3_config.json

Machine-readable model and benchmark configuration.

Reproducibility

The official BHI-2000 model uses:

Seed: 20261003

The same seed controls the image selection and train/test split.

The official split contains:

1,800 training images 200 unseen test images

with zero overlap.

Model Philosophy

Supernova Creation V3 follows the Supernova approach of building systems from understandable components rather than hiding the core capability behind a large pretrained pipeline.

The architecture is intentionally inspectable:

Convolution

  • GroupNorm
  • SiLU
  • Residual blocks
  • Latent representation
  • Decoder

The complete model can be inspected in "model.py".

There is no external pretrained image-generation backbone inside the V3 architecture.

A First Working Supernova Image Generator

Supernova Creation V3 represents an important milestone in the Supernova project.

It demonstrates that a relatively compact, from-scratch neural architecture can learn useful visual representations, reconstruct unseen images, and generate new images from its learned latent space.

V3 is the foundation for future Supernova image-generation research.

This is only the beginning.

Project

Supernova11c

Model:

Supernova Creation TeraiLLM V3

Repository:

Supernova-Creation-TeraiLLM-V3

# ================================================================
# SUPERNOVA CREATION TERAILLM V3
# FRESH RUNTIME QUICK START
# ================================================================

!pip -q install torch numpy pillow huggingface_hub

from huggingface_hub import hf_hub_download
from pathlib import Path
import urllib.request

REPO_ID = "Supernova11c/Supernova-Creation-TeraiLLM-V3"

# ------------------------------------------------
# Download the required files
# ------------------------------------------------

for filename in [
    "model.py",
    "configuration.py",
    "interface.py",
]:
    hf_hub_download(
        repo_id=REPO_ID,
        filename=filename,
        local_dir="/content/supernova_v3"
    )

checkpoint = hf_hub_download(
    repo_id=REPO_ID,
    filename="supernova_creation_v3_bhi2000.pt",
    local_dir="/content/supernova_v3"
)

# ------------------------------------------------
# Enter model directory
# ------------------------------------------------

%cd /content/supernova_v3

# ------------------------------------------------
# Load and generate
# ------------------------------------------------

from interface import SupernovaCreationV3Interface

model = SupernovaCreationV3Interface(
    checkpoint_path=checkpoint,
    device="cuda" if __import__("torch").cuda.is_available() else "cpu"
)

image = model.generate(
    seed=20261003
)

model.save_image(
    image,
    "supernova_v3_generated.png"
)

print("=" * 60)
print("SUPERNOVA CREATION TERAILLM V3")
print("GENERATION COMPLETE")
print("=" * 60)
print("Output: /content/supernova_v3/supernova_v3_generated.png")

πŸ‡³πŸ‡΅ Supernova Vision

Supernova AI Built in Nepal powering AI infrastructure by CPU not GPU

Built in Nepal. Built for Nepal. Built for the World.

Supernova is being built from Nepal with a long-term goal of creating world-class AI technology that can serve Nepal first and eventually users everywhere.

Our vision includes building strong AI systems for Nepali language, Nepali culture, local knowledge, and local use cases β€” rather than assuming that every AI system must be designed around the needs of larger international markets.

Nepali Image Generation

One of Supernova's long-term goals is a capable Nepali-focused image-generation system.

Future versions are intended to explore:

  • Nepali text-to-image generation
  • Nepali-language visual understanding
  • Nepal-focused datasets
  • Nepali cultural and geographical imagery
  • Local visual concepts and terminology
  • Text-conditioned image generation
  • Efficient inference on consumer hardware

Supernova Creation V3 is an early foundation for this direction. V3 itself currently generates images from latent representations and does not yet provide text-prompt conditioning.

Efficient AI

Supernova also has a strong interest in efficient AI.

We want capable models to become increasingly accessible without requiring enormous infrastructure.

Our long-term direction is:

Less infrastructure. More intelligence.

Where practical, Supernova aims to develop models that can run on ordinary computers and eventually push the limits of what can be achieved with CPU-based inference.

GPU acceleration remains useful for training and experimentation, but efficient inference is an important design goal.

From Nepal to the World

Supernova is being built in Nepal.

Our ambition is not simply to reproduce existing AI systems. We want to explore our own architectures, our own datasets, and our own engineering approaches.

Built in Nepal.
Built for Nepal.
Designed to reach the world.

Supernova Creation V3 is one step toward that vision.

Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
Text-to-Image
This model isn't deployed by any Inference Provider. πŸ™‹ Ask for provider support

Dataset used to train Supernova11c/Supernova-Creation-TeraiLLM-V3