MOSS-Image-SFT

MOSS-Image-SFT

A text-to-image model from OpenMOSS, fine-tuned from MOSS-Image-Base, that reads plain prompts, tags or JSON layouts to place text and objects. For people who generate images with diffusers on an NVIDIA GPU.

Made by OpenMOSS-Team 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: MOSS-Image-SFT is a text-to-image model from OpenMOSS, part of the MOSS-Image family. It is a supervised fine-tune of MOSS-Image-Base and shares the architecture and pipeline of that model. You can write a plain-language prompt, a list of tags, or a JSON layout that says where text and objects should go. It works in English and Chinese.

Who it suits: It suits people who want images with readable text and a planned layout, and developers who run an image model through diffusers.

Industry | Who uses it | How they use it | Example
Design | Designers | Describe a layout in JSON to place text and objects | A poster with a headline in a set spot
Marketing | Content staff | Make visuals with clear lettering from a prompt | A banner with a short slogan
Software | Developers | Call the model from Python with diffusers | An app that returns an image for each prompt
AI research | Researchers | Compare the Base model with the fine-tuned one | The same prompt run through both

If you have no NVIDIA GPU, you can skip it, since the card asks for CUDA.

Where to use it:

• Python with the diffusers library
• A computer with an NVIDIA GPU that supports CUDA
• Any Windows, macOS or Linux machine for downloading the files

Use case | Who | What they get back
Prompt to image | Designers | A picture made from a plain-language prompt
Layout control | Marketers | Text and objects placed where a JSON layout says
Tag-based prompts | Developers | Images made from a sequence of tags

How to set it up: You need these first:

• Python 3.10 or later
• An NVIDIA GPU with CUDA support
• PyTorch 2.9 or later, built for your CUDA setup
• About 10.2 GB of disk for the BF16 weights

1. Install a PyTorch build that matches your CUDA environment.
2. Install the Python libraries from the first code block below.
3. Download the model files with the second code block, or let diffusers fetch them on first load.
4. Load the pipeline with the Python code in the next section.

pip install "diffusers>=0.38" "transformers>=5.3" "accelerate>=1.10" "safetensors>=0.6" "Pillow>=10"

pip install -U huggingface_hub
hf download OpenMOSS-Team/MOSS-Image-SFT

How to use it: Load the pipeline in Python, then give it a prompt, a tag list or a JSON layout. The part of the card given here ends before the call that makes the image, so read the full card for that step.

import torch
from diffusers import DiffusionPipeline
pipe = DiffusionPipeline.from_pretrained(
    "OpenMOSS-Team/MOSS-Image-SFT",
    custom_pipeline="pipeline_moss_image",
    trust_remote_code=True,
    torch_dtype={"default": torch.bfloat16, "vae": torch.float32},
)

Tool | What it does
DiffusionPipeline | Loads the model through diffusers
custom_pipeline="pipeline_moss_image" | Picks the MOSS-Image pipeline code
trust_remote_code=True | Lets that pipeline code run when the model loads
torch_dtype | Sets the data type for the model and for the VAE

Example: You load the pipeline, then ask for a whiteboard picture with a short list of tasks, and you give a JSON layout for where each line goes. The card does not show this exact run, so treat it as an expectation. The card says the fine-tuned model groups text more clearly than the Base model.

For newcomers and experts: A fine-tune starts from a base model and trains it further on chosen examples. A good first step is a plain-language prompt, and later you can try tags or a JSON layout for more control.

Because the architecture and pipeline match the Base model, setups built for the Base model should carry over. Other people have published 51 quantized and 26 fine-tuned versions of this model.

Write a prompt, tags or a JSON layout
Load the pipeline with diffusers
Generate the image
Check the text and the layout

Good to know: The weights are about 10.2 GB in BF16, and about 2.5 GB at 4-bit by Hugging Face's own estimate.

Title: Weight size in GB
BF16 weights: 10.2 GB
4-bit estimate: 2.5 GB

• Base model: MOSS-Image-Base, with the same architecture and pipeline
• Hardware: needs an NVIDIA GPU with CUDA support
• License: Apache 2.0
• Cost to run: none named, you supply the GPU
• Data it reaches: the prompts and layouts you give it, and the model files you download

On Hugging Face, 13 November 2026

• Task: text to image
• Library: diffusers
• Parameters: 5.1B
• Weights: about 10.2 GB in BF16; about 2.5 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 22,963
• Likes: 950
• License: apache-2.0
• Languages: en, zh
• Based on: OpenMOSS-Team/MOSS-Image-Base
• Quantized versions: 53
• Fine-tunes: 26
• Tags: diffusers, safetensors, moss-image, text-to-image

Links

• Model: https://huggingface.co/OpenMOSS-Team/MOSS-Image-SFT
• Files: https://huggingface.co/OpenMOSS-Team/MOSS-Image-SFT/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download OpenMOSS-Team/MOSS-Image-SFT

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