Model reference · open weights

Aria-64K

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

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

  • Aria-64K is a 25.3B parameter multimodal model developed by rhymes-ai for image-text-to-text tasks.
  • It is designed for research and continue training, specifically supporting long-context scenarios with a 64K sequence length and the ability to process up to 250 high-resolution images.
  • The model is released under the Apache 2.0 license and supports English.

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

What it is

Released byrhymes-ai
Released2024-11-30
Parameters25.3B
VRAM50.6 GB for the weights

What it runs on

Memory and cards for Aria-Base-64K (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-64K

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-64K corresponds to the model checkpoint after the long-context pre-training stage (boxed in purple).

Aria-Base-64K is fine-tuned from Aria-Base-8K.

Aria-Base-64K

  • Base Model After Long-Context Pre-training: This model corresponds to the model checkpoint after the long-context pre-training stage, with 33B tokens (21B multimodal, 12B language, 69% in long-form) trained in this stage. This stage lasts 1,000 iterations, with all sequences packed to 65536 with Megatron-LM, with global batch size 512. During this training stage, the learning rate keeps constant at 3.5e-5.
  • Appropriate for Video and Long-document Fine-tuning: This model is recommended for long-form continue pre-training or fine-tuning, e.g. on video QA datasets or long-document QA datasets. While resource is limited, it is also possible to post-train this model with short instruction tuning datasets and transfer to long-form QA scenarios.
  • Understanding on Hundreds of Images: This model is capable of understanding up to 250 high-resolution images or up to 500 mid-resolution images.
  • Strong Base Performance on Language and Multimodal Scenarios: This model retains strong base performance as Aria-Base-8K.
  • 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 with chat templates.

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-64K"

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