DiT-Wikiart-Small

DiT-Wikiart-Small

Predicts noise for a small diffusion transformer trained from scratch on Wikiart paintings, built to make art images from a genre and a style. For developers and students who study small image models.

Made by kaupane on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: DiT-Wikiart-Small is the small variant of a diffusion transformer trained from scratch on the Wikiart collection of paintings. It is built to make art images from a chosen art genre and art style. Images come out at 256x256.

Who it suits: It suits developers and students who want to study a small diffusion transformer, and researchers who want a simple genre and style model.

Industry | Who uses it | How they use it | Example
Software | Developers | Study a small diffusion transformer built from scratch | Load it and print the noise it predicts
Education | Students | Learn how this model differs from the classic design | Compare its changes with the original paper
Art | Artists and hobbyists | Explore painting genres and styles at low resolution | Try styles from the Wikiart collection
Research | ML researchers | Test training on a modest budget | Compare the S, B and L variants

If you need photographs, faces or buildings, you can skip it, since the card says it handles faces and buildings poorly and cannot make images outside Wikiart.

Where to use it:

• Python with torch and the huggingface_hub library
• A machine with room for about 88 MB of weights
• Windows, macOS or Linux, where you download the files with Python

Use case | Who | What they get back
Model study | Developers | A small DiT you can load and inspect
Training study | Students | A model with its recipe, epochs and loss numbers
Art experiments | Hobbyists | A starting point for genre and style images at 256x256

How to set it up: You need Python with pip, torch and the huggingface_hub library. The model definition file, modeling_dit_wikiart.py, comes from the repository's file list.

• Python and pip
• torch and the huggingface_hub library
• The definition file modeling_dit_wikiart.py from this repository
• About 88 MB of disk in F32, or about 11 MB at 4-bit, which is an estimate
• The VAE the card pairs it with, stabilityai/sd-vae-ft-ema, to turn latents into images

1. Install the Hugging Face client with pip.
2. Download the repository with the hf command, which includes the definition file.
3. Run the sample from a folder that holds that file.

pip install -U huggingface_hub
hf download kaupane/DiT-Wikiart-Small

How to use it: Import the model class from the definition file, load the weights by name, and pass noisy latents. The card's sample runs one pass and prints the predicted noise. It shows no full picture-making loop, and it needs torch imported first.

from modeling_dit_wikiart import DiTWikiartModel

model = DiTWikiartModel.from_pretrained("kaupane/DiT-Wikiart-Small")
num_samples = 8
noisy_latents = torch.randn(num_samples,4,32,32)
predicted_noise = model(noisy_latents)
print(predicted_noise)

Name | What it does
DiTWikiartModel | Loads the model from the definition file and the Hub
num_samples | Sets how many noisy latents are made, 8 in the sample
torch.randn | Makes random noise shaped 4 by 32 by 32
predicted_noise | Holds what the model predicts for each latent

Example: You run the sample. It makes 8 random noisy latents, passes them through the model and prints the predicted noise for each one. It does not yet give you a finished painting.

For newcomers and experts: Think of it as a small artist that learns to remove noise, guided by a genre and a style. The first small thing to try is the sample above.

The design follows the classic DiT from its original paper, with a few changes. Genre and style embeddings replace the ImageNet class embeddings. It uses post-norm and learned positional embeddings, leaves out the final linear layer, predicts only the noise, and sets patch_size to 2.

Variant | Blocks | Hidden size | Heads | Parameters
S, small | 8 | 384 | 6 | 20M
B, base | 12 | 640 | 10 | 90M
L, large | 16 | 896 | 14 | 234M

Random noisy latents
DiT predicts the noise, guided by genre and style
Repeated denoising gives a clean latent
Paired VAE decodes it into an image

Good to know:

• Size: Hugging Face lists 22M parameters, while the card says 20M for this small variant.
• Training: all variants trained on 103K Wikiart images with horizontal flips, using AdamW with default settings and a learning rate that peaks at 3e-4 before a cosine decay.

Title: Parameters in millions
S small: 20 M
B base: 90 M
L large: 234 M

Variant | Epochs | Batch size | Final loss
S | 96 | 176 | 0.1590
B | 120 | 192 | 0.1525
L | 144 | 192 | 0.1510

• Loss: in every variant it dropped sharply during epoch one, starting above 1.0000 and ending near 0.2000, then eased down slowly.
• Strengths: the card says the models show a basic grasp of genres and styles and make paintings that look good at first glance.
• Limits: it struggles with complex shapes such as faces and buildings, and it can repeat itself for rare styles such as minimalism.
• Scope: it was trained only on Wikiart, so it cannot make images outside that scope.
• License: MIT, as the License line says.
• Cost to run: no API key, account or paid service is named.
• Data it reaches: nothing beyond Hugging Face for the download.
• Not for: photographs, faces or buildings, which the card lists as weak points.

On Hugging Face, 13 November 2026

• Task: text to image
• Parameters: 22M
• Weights: about 88 MB in F32; about 11 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 75
• Likes: 2
• License: mit
• Tags: safetensors, model_hub_mixin, pytorch_model_hub_mixin, text-to-image

Links

• Model: https://huggingface.co/kaupane/DiT-Wikiart-Small
• Files: https://huggingface.co/kaupane/DiT-Wikiart-Small/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download kaupane/DiT-Wikiart-Small

Then follow the usage in its model card. Nothing in this kit runs by itself.