Model reference · open weights

Aria-8K

LLMs rhymes-ai Vision + text 1 build Open weights 30 dl/mo

Aria-8K is an open-weight language model from rhymes-ai. Aria-Base-8K (BF16) weighs 50.6 GB; the smallest configuration that runs it is H100 80 GB.

  • Aria-8K is a 25.3B parameter multimodal model by rhymes-ai designed for image-text-to-text tasks.
  • It serves as a base checkpoint after multimodal pre-training, suitable for research and continued training on domain-specific data.
  • The model supports English with an 8K context length and is released under the Apache-2.0 license.

Summary of the rhymes-ai/Aria-Base-8K model card, 2026-10-01

What it is

Released byrhymes-ai
Released2024-12-01
Parameters25.3B
VRAM50.6 GB for the weights

What it runs on

Memory and cards for Aria-Base-8K (BF16)

50.6 GBweights, file size
287 MBcache per 1K tokens
2.6 GBruntime overhead, at least
65,536 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB … L40S 48 GB
6 smaller cards
———
A100 80 GB102all 64K78.2 GB
H100 80 GB82all 64K78.1 GB
RTX PRO 6000 Blackwell 96 GB143all 64K93.8 GB
DGX Spark (GB10) 128 GB unified205all 64K107 GB
H200 141 GB338all 64K138 GB
B200 180 GB4812all 64K176 GB
2× L40S 48 GB
tensor parallel
133all 64K44.0 GB a card
4× RTX 4090 24 GB
tensor parallel
133all 64K23.4 GB a card
4× RTX 3090 24 GB
tensor parallel
133all 64K23.4 GB a card
4× RTX 5090 32 GB
tensor parallel
266all 64K31.0 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
155.5 GB62.6 GB
564.9 GB100 GB
872.0 GB128 GB
1690.8 GB203 GB
32128 GB354 GB
64203 GB654 GB

One card, with vLLM's small-card settings.

From the model card

What rhymes-ai says about Aria-8K

Read the model card

🔗 Try Aria! · 📖 Blog · 📌 Paper · ⭐ GitHub · 🟣 Discord

This checkpoint is one of base models of Aria, designed for research purposes as well as continue training. Specifically, Aria-Base-8K corresponds to the model checkpoint after the multimodal pre-training stage (boxed in gray).

Aria-Base-8K

  • Base Model After Pre-training: This model corresponds to the model checkpoint after the multimodal pre-training stage, with 1.4T tokens (1T language + 400B multimodal) trained in this stage. This stage lasts 43,000 iterations, with all sequences packed to 8192 with Megatron-LM, with global batch size 4096. During this training stage, the learning rate decays from 8.75e-5 to 3.5e-5.
  • Appropriate for Continue Pre-training: This model is recommended for continue pre-training, e.g. on domain-specific pre-training data (OCR, agent, multi-lingual), while the targeted scenario does not involve long-context inputs. Please consider fine-tuning Aria-Base-64K for long-context scenarios.
  • Strong Base Performance on Language and Multimodal Scenarios: This model shows excellent base performance on knowledge-related evaluations on both pure language and multimodal scenarios (MMLU 70+, MMMU 50+, etc).
  • Limited Ability on Long-context Scenarios: This model is only trained with 8K context length, and is not expected to show best performance with context length especially longer than 8K (e.g. a video with >100 frames). Aria-Base-64K is more appropriate for longer sequence understanding.
  • Limited Chat Template Availability: This model is trained with a very low percentage of data (around 3%) re-formatted with the chat template. Hence, it might not be optimal to be directly used for chatting.

Quick Start

Installation

pip install transformers==4.45.0 accelerate==0.34.1 sentencepiece==0.2.0 torchvision requests torch Pillow
pip install flash-attn --no-build-isolation

# For better inference performance, you can install grouped-gemm, which may take 3-5 minutes to install
pip install grouped_gemm==0.1.6

Inference

You can use the same method as the final Aria model to load this checkpoint. However, as the base model, it might not be able to yield optimal chat performance.

import requests
import torch
from PIL import Image
from transformers import AutoModelForCausalLM, AutoProcessor

model_id_or_path = "rhymes-ai/Aria-Base-8K"

model = AutoModelForCausalLM.from_pretrained(model_id_or_path, device_map="auto", torch_dtype=torch.bfloat16, trust_remote_code=True)

processor = AutoProcessor.from_pretrained(model_id_or_path, trust_remote_code=True)

image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png"

image = Image.open(requests.get(image_path, stream=True).raw)

messages = [
    {
        "role": "user",
        "content": [
            {"text": None, "type": "image"},
            {"text": "what is the image?", "type": "text"},
        ],
    }
]

text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(text=text, images=image, return_tensors="pt")
inputs["pixel_values"] = inputs["pixel_values"].to(model.dtype)
inputs = {k: v.to(model.device) for k, v in inputs.items()}

with torch.inference_mode(), torch.cuda.amp.autocast(dtype=torch.bfloat16):
    output = model.generate(
        **inputs,
        max_new_tokens=500,
        stop_strings=[""],
        tokenizer=processor.tokenizer,
        do_sample=True,
        temperature=0.9,
    )
    output_ids = output[0][inputs["input_ids"].shape[1]:]
    result = processor.decode(output_ids, skip_special_tokens=True)

print(result)

Advanced Inference and Fine-tuning

We provide a codebase for more advanced usage of Aria, including vllm inference, cookbooks, and fine-tuning on custom datasets.

As it shares the same structure with the final model, you may just replace the rhymes-ai/Aria to this model path for any advanced inference and fine-tuning.

Citation

If you find our work helpful, please consider citing.

@article{aria,
  title={Aria: An Open Multimodal Native Mixture-of-Experts Model},
  author={Dongxu Li and Yudong Liu and Haoning Wu and Yue Wang and Zhiqi Shen and Bowen Qu and Xinyao Niu and Guoyin Wang and Bei Chen and Junnan Li},
  year={2024},
  journal={arXiv preprint arXiv:2410.05993},
}

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms