---
library_name: diffusers
pipeline_tag: text-to-image
tags:
- diffusion
- diffusers
- text-to-image
- pytorch
- experimental
datasets:
- huggan/smithsonian-butterfly-lowres
---

# my-small_diff-model

`my-small_diff-model` is an experimental diffusion model trained as part of a hands-on study of diffusion model training, optimization, and image generation workflows.

The model was trained for **50 epochs on a single GPU**, reaching **3,149 optimization steps**. Training behavior, learning-rate scheduling, and periodic image generation were monitored throughout the run.

This repository is intended primarily as a reproducible machine learning engineering experiment rather than a production-ready generative model.

## Model Details

### Model Description

This model was trained using the Hugging Face `diffusers` ecosystem as an experimental small diffusion model.

The project focuses on understanding the practical behavior of diffusion training, including:

* convergence over repeated epochs
* learning-rate scheduling
* training stability
* single-GPU training
* periodic qualitative sampling
* packaging and publishing a diffusion model through the Hugging Face Hub

**Developed by:** [Priyanka / pynk17](https://huggingface.co/pynk17)

**Model type:** Diffusion-based generative image model

**Task:** Image generation

**Framework:** PyTorch / Hugging Face Diffusers

**Training hardware:** Single GPU

**Training epochs:** 50

**Total optimization steps:** 3,149

**Repository:** https://huggingface.co/pynk17/my-small_diff-model

**License:** Not specified

**Base model:** Not documented in the available training metadata

## Intended Uses

### Direct Use

The model can be used for experimentation with diffusion-model inference and for studying the behavior of a relatively small generative model trained from a limited training setup.

Possible uses include:

* studying diffusion inference
* experimenting with sampling behavior
* investigating the relationship between training loss and generated output quality
* testing Hugging Face Diffusers workflows
* educational demonstrations of diffusion training and deployment
* reproducibility experiments

### Downstream Use

The model may also be useful as a starting point for:

* additional fine-tuning
* inference optimization experiments
* mixed-precision comparisons
* memory optimization studies
* checkpointing experiments
* scheduler comparisons
* model deployment experiments

The model should be treated as an experimental research artifact rather than a production model.

### Out-of-Scope Use

This model has not been validated for safety-critical, commercial, or production deployment.

It should not be assumed to provide:

* photorealistic image generation
* robust prompt following
* unbiased outputs
* production-level reliability
* safety filtering
* factual or semantically reliable image generation

## Training Details

### Training Data

The model was trained using a custom image training dataset supplied to the training pipeline.

Further dataset documentation should include:

* dataset name
* number of training images
* image resolution
* preprocessing steps
* captioning or conditioning strategy, if applicable
* dataset license and provenance

These details are not available in the current training metadata and should be added when confirmed.

## Training Procedure

Training was launched on **one GPU** and executed for **50 epochs**.

Each epoch contained approximately **63 training iterations**, resulting in a final training step of **3,149**.

The run also included periodic image-generation passes. The logs show **1,000-step generation/sampling loops** occurring at several points during training, each executing at approximately **34.8 iterations per second**.

### Optimization Behavior

Training began with a learning rate of approximately:

`1.26e-5`

The learning rate increased during the early training phase, reaching approximately:

`1.0e-4`

around epoch 7.

It then gradually decayed through the remainder of training until reaching:

`0`

at the end of epoch 49.

This indicates a learning-rate schedule containing an initial warm-up phase followed by gradual decay.

### Training Loss

The reported training loss decreased substantially during training.

Early training:

| Epoch | Step | Loss | Learning Rate |
|---:|---:|---:|---:|
| 0 | 62 | 0.358 | 1.26e-5 |
| 1 | 125 | 0.125 | 2.52e-5 |
| 2 | 188 | 0.104 | 3.78e-5 |
| 3 | 251 | 0.0252 | 5.04e-5 |
| 4 | 314 | 0.0166 | 6.30e-5 |

During later training, losses frequently fell below `0.02`, although noticeable fluctuations remained throughout the run.

Examples include:

| Epoch | Step | Loss | Learning Rate |
|---:|---:|---:|---:|
| 14 | 944 | 0.00669 | 9.32e-5 |
| 26 | 1700 | 0.00594 | 5.73e-5 |
| 32 | 2078 | 0.00350 | 3.52e-5 |
| 39 | 2519 | 0.00656 | 1.33e-5 |
| 47 | 3023 | 0.00176 | 5.57e-7 |
| 49 | 3149 | 0.0384 | 0 |

The lowest reported loss in the supplied logs was approximately:

**0.00176 at epoch 47**

Loss was not monotonically decreasing. Temporary increases occurred at several points, including epochs 7, 11, 18, 19, 22, 33, and 43.

This behavior is not unexpected for stochastic diffusion training because each loss measurement reflects the sampled training batch, diffusion timestep, and injected noise rather than a deterministic full-dataset objective.

## Training Progress

A simplified view of the run is shown below.

| Training stage | Approximate loss behavior |
|---|---|
| Epochs 0–4 | Rapid initial reduction from 0.358 to ~0.017 |
| Epochs 5–15 | Mostly low losses with occasional spikes |
| Epochs 16–30 | Stable low-loss regime with stochastic fluctuations |
| Epochs 31–40 | Continued low-loss optimization as LR decayed |
| Epochs 41–49 | Very low learning rate and final convergence phase |

The final epoch completed at:

**Epoch:** 49  
**Step:** 3,149  
**Reported loss:** 0.0384  
**Learning rate:** 0

Because the logged value represents the final observed batch rather than an epoch-averaged validation metric, it should not be interpreted as the model's overall evaluation score.

## Training Throughput

Training throughput was generally stable at approximately:

**7.1 to 7.3 iterations per second**

Most epochs contained:

**63 / 63 training iterations**

Periodic generation loops ran at approximately:

**34.8 iterations per second**

This suggests relatively stable computational throughput during the training run.


## Results

Training completed successfully for all **50 epochs** and **3,149 optimization steps**.

The logs show:

* rapid reduction in loss during early training
* stable single-GPU throughput
* successful completion of the full training schedule
* gradual learning-rate warm-up followed by decay
* periodic image-generation passes throughout training
* occasional stochastic loss spikes despite a generally low-loss regime

These results demonstrate successful end-to-end execution of the diffusion training pipeline.

They do **not**, by themselves, establish image-generation quality. Diffusion training loss is useful for monitoring optimization but should be interpreted alongside generated samples and dedicated generative evaluation metrics.

## Model Examination

One important observation from the training run is that diffusion loss is visibly noisy.

For example, the reported loss moved from:

`0.0151` at epoch 6

to:

`0.129` at epoch 7

and subsequently returned to:

`0.0134` at epoch 8.

Similar short-term increases occurred later in training.

This illustrates an important property of diffusion-model optimization: individual training loss measurements can fluctuate substantially because the training objective depends on randomly sampled images, noise levels, timesteps, and noise realizations.

As a result, isolated loss values should not be used as the sole criterion for judging generative quality.



## How to Get Started

The exact loading code depends on how the model components were serialized in this repository.

For a standard Hugging Face Diffusers pipeline, inference typically follows this pattern:

```python
import torch
from diffusers import DiffusionPipeline

model_id = "pynk17/my-small_diff-model"

pipe = DiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
)

pipe = pipe.to("cuda")

prompt = "your prompt here"

image = pipe(prompt).images[0]
image.save("generated_image.png")