HEART

HEART

Upscales low-resolution images with a super-resolution network that trains on one consumer GPU and exports to ONNX. For people who train or run image upscalers.

Made by Phips 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: HEART is a super-resolution network design from Phips, part of the author's BODY suite. The name stands for a hybrid attention transformer with a rank-factorized bias. It turns a small image into a larger one, and the models were trained with traiNNer-redux on a single RTX 3060 with 12 GB.

Who it suits: People who train or run image upscalers and want a design that exports cleanly to ONNX. It suits those already comfortable with a training toolkit and a command line.

Industry | Who uses it | How they use it | Example
Image restoration | Hobbyist model trainers | Train a 4x upscaler on their own data | Start from the released 4x pretrain and fine-tune it
Photo and anime upscaling | Enthusiasts | Enlarge noisy or compressed pictures | The card shows 4x results on anime and noisy images
ML research | Super-resolution researchers | Compare attention designs for upscaling | Weigh HEART against HAT_M on PSNR and memory

Anyone who wants a finished app with a button can skip it, since this is a network to train and convert.

Where to use it:

• traiNNer-redux: the training toolkit the released models were checked with.
• ONNX Runtime: the runtime the exported models were checked with.
• TensorRT and other runtimes: expected to work, but not tested by the author.
• Windows, macOS or Linux: the download steps run on all three with Python.

Use case | Who | What they get back
Train an upscaler | Model trainers | A 4x super-resolution model trained from the HEART architecture
Export to ONNX | Developers | A dynamic ONNX file made with the official converter
Restore real photos | Enthusiasts | Larger pictures from models trained on the Real-ESRGAN degradation chain

How to set it up: What you need first:

• Python with pip.
• A checkout of traiNNer-redux.
• Training images for your own run.
• A GPU. The author trained on an RTX 3060 with 12 GB.

1. Download the files with the hf command.
2. Copy heart_arch.py into the archs folder of traiNNer-redux.
3. Copy a training config into its options folder.
4. Train, then export to ONNX with the converter.

pip install -U huggingface_hub
hf download Phips/HEART

# 1. Add the architecture (auto-registers: traiNNer scans *_arch.py)
cp heart_arch.py <traiNNer-redux>/traiNNer/archs/

# 2. Copy a training config and point it at your data
cp configs/4x_HEART_release.yml <traiNNer-redux>/options/

# 3. Train
cd <traiNNer-redux>
python train.py -opt options/4x_HEART_release.yml --auto_resume

# 4. Export to optimized dynamic ONNX (official converter)
cp configs/4x_HEART_onnx.yml <traiNNer-redux>/options/
python convert_to_onnx.py -opt options/4x_HEART_onnx.yml

How to use it: Train with the config above, then run the ONNX file in ONNX Runtime. Use 96 for lq_size. It has to divide evenly by 32, the window size. For a warm start, set path.pretrain_network_g in the training config to the released 4x pretrain, models/heart_4x_pretrain.safetensors.

Title: Files and commands the card names
Tool | What it does
heart_arch.py | The HEART network, which traiNNer-redux registers by itself
4x_HEART_release.yml | A training config for the 4x release model
train.py | Runs training from a config, with auto resume
convert_to_onnx.py | Exports a trained model to dynamic ONNX

Example: You copy the architecture file into traiNNer-redux, train the 4x config with lq_size 96, and export it to ONNX. Then you run a noisy photo through the ONNX file in ONNX Runtime and get a picture at four times the size.

For newcomers and experts: Super-resolution means making a small picture larger and sharper. HEART is the network design behind that, not a ready app. A good first step is to copy the architecture file into traiNNer-redux and start from the released 4x pretrain.

The design uses attention with no masks and no position-bias table lookups. A rank-factorized bias replaces them with a dot product, which suits FlashAttention and SDPA. An i-LN layer keeps bf16 training stable. The code is one pure PyTorch file. The trade-off is that for the top benchmark PSNR or a small mobile model, the author points to NERVE instead.

Copy heart_arch.py into traiNNer-redux
Train with lq_size set to 96
Export dynamic ONNX with the converter
Run the file in ONNX Runtime

Good to know: The card compares HEART with HAT_M on training memory. PSNR is 25.02 dB for HEART and 25.05 dB for HAT_M, which the author calls within noise.

Title: Training VRAM
HEART: 1.44 GB
HAT_M: 2.84 GB

• Inference: at bf16 it is about 1.2x faster with about 2.7x less VRAM than HAT_M.
• Tested runtimes: only ONNX Runtime was verified.
• License: apache-2.0
• Cost to run: no API key, account or paid service named.
• Data it reaches: files you download from Hugging Face, and the images you train on or upscale.
• Not for: top benchmark PSNR or small mobile models, where the card suggests NERVE.

On Hugging Face, 15 November 2026

• Task: image to image
• Library: pytorch
• Downloads in the last 30 days: 0
• Likes: 15
• License: apache-2.0
• Languages: en
• Fine-tunes: 2
• Tags: pytorch, onnx, super-resolution, image-restoration, image-to-image, sisr, real-world-restoration, tensorrt, spandrel, chainner, transformer, attention

Links

• Model: https://huggingface.co/Phips/HEART
• Files: https://huggingface.co/Phips/HEART/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Phips/HEART

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