Model reference · open weights

falcon-mamba

LLMs tiiuae Text gen 1 build Its own licence terms 65k dl/mo

falcon-mamba is an open-weight language model from tiiuae. falcon-mamba-7b (BF16) weighs 14.5 GB; the smallest configuration that runs it is RTX 4060 Ti 16 GB.

  • Falcon-Mamba is a 7.3B parameter causal decoder-only language model developed by TII UAE for text generation tasks.
  • It utilizes the Mamba architecture and is primarily designed for English, with a training context length of 8,192 tokens.
  • The model is released under the TII Falcon-Mamba License 2.0.

Summary of the tiiuae/falcon-mamba-7b model card, 2026-10-01

What it is

Released bytiiuae
Released2024-07-17
Parameters7.3B
VRAM14.5 GB for the weights

What it runs on

Memory and cards for falcon-mamba-7b (BF16)

14.5 GBweights, file size
0 MBcache per 1K tokens
40 MBfixed state per request
630 MBruntime overhead, at least
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB———11.6 GB
RTX 4060 Ti 16 GB55128K15.4 GB
RTX 3090 24 GB206206128K23.4 GB
RTX 4090 24 GB205205128K23.4 GB
RTX 5090 32 GB397397128K31.0 GB
L40S 48 GB722722128K44.0 GB
A100 80 GB1000+1000+128K78.2 GB
H100 80 GB1000+1000+128K78.1 GB
RTX PRO 6000 Blackwell 96 GB1000+1000+128K93.8 GB
DGX Spark (GB10) 128 GB unified1000+1000+128K107 GB
H200 141 GB1000+1000+128K138 GB
B200 180 GB1000+1000+128K176 GB
Memory needed at each load
Requests at once8K tokens each32K tokens each
115.2 GB15.2 GB
515.4 GB15.4 GB
815.5 GB15.5 GB
1615.8 GB15.8 GB
3216.5 GB16.5 GB
6417.7 GB17.7 GB

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

From the model card

What tiiuae says about falcon-mamba

Read the model card
  1. TL;DR
  2. Model Details
  3. Usage
  4. Training Details
  5. Evaluation

TL;DR

Model Details

Model Description

  • Developed by: https://www.tii.ae
  • Model type: Causal decoder-only
  • Architecture: Mamba
  • Language(s) (NLP): Mainly English
  • License: TII Falcon-Mamba License 2.0

Check out the blogpost for more details!

Usage

Find below some example scripts on how to use the model in transformers (Make sure to have the latest transformers, or the one built from source):

Using the Pytorch model

Running the model on a CPU

from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b")
model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-mamba-7b")

input_text = "Question: How many hours in one day? Answer: "
input_ids = tokenizer(input_text, return_tensors="pt").input_ids

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))

Running the model on a GPU

# pip install accelerate
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b")
model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-mamba-7b", device_map="auto")

input_text = "Question: How many hours in one day? Answer: "
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to("cuda")

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))

Running the model on a GPU using torch.compile

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b")
model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-mamba-7b", torch_dtype=torch.bfloat16).to(0)

model = torch.compile(model)

input_text = "Question: How many hours in one day? Answer: "
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to("cuda")

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))

Running the model on a GPU using different precisions

FP16
# pip install accelerate
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b")
model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-mamba-7b", device_map="auto", torch_dtype=torch.float16)

input_text = "Question: How many hours in one day? Answer: "
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to("cuda")

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))
4-bit
# pip install bitsandbytes accelerate
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-mamba-7b")
model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-mamba-7b", device_map="auto", quantization_config=BitsAndBytesConfig(load_in_4bit=True))

input_text = "Question: How many hours in one day? Answer: "
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to("cuda")

outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0]))

Training Details

Training Data

Falcon-Mamba has been trained with ~ 5,500 GT mainly coming from Refined-Web, a large volume web-only dataset filtered and deduplicated. Similar to the others Falcon suite models, Falcon-Mamba has been trained leveraging a multi-stage training strategy to increase the context-length from 2,048 to 8,192. Moreover, inspired by the concept of Curriculum Learning, we carefully selected data mixtures throughout the training stages, considering both data diversity and complexity. Note that at inference the context-length is not relevant as the Mamba architecture has no limit on long range dependency. At the last training stage, small portion of high-quality curated data was used to further enhance performance.

Overall, the data sources included RefinedWeb-English, high quality technical data, code data and math data extracted from public sources. In particular, we used samples coming from Fineweb-edu during our last training stage.

The data was tokenized with the Falcon-7B/11B tokenizer.

Training Procedure

Falcon-Mamba-7B was trained on 256 H100 80GB GPUs for the majority of the training, using a 3D parallelism strategy (TP=1, PP=1, DP=256) combined with ZeRO.

Training Hyperparameters

HyperparameterValueComment
Precisionbfloat16
OptimizerAdamW
Max learning rate6.4e-4Following a WSD (warmup-stable-decay) learning rate schedule
Weight decay1e-1
Batch size2048

The model was trained AdamW optimizer, WSD (warmup-stable-decay) learning rate schedule, and a batch size rampup from \(b_{\mathrm{min}}=128\) to \(b_{\mathrm{max}}=2048\) during first 50 GT of training. In the stable phase we used maximal learning rate \(\eta_{\mathrm{max}}=6.4 \times 10^{-4}\), and decayed it to the minimal value \(\eta_{\mathrm{min}}=\frac{\eta_{\mathrm{max}}}{256}\) with exponential schedule over 500 GT. Also, we applied BatchScaling during the rampup — rescaling learning rate \(\eta\) so that the Adam noise temperature \(T_{\mathrm{noise}}\

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

Benchmarks

Reported results

As published on the model card: the maker's own numbers, not measured by AxForge.

TaskDatasetMetricScore
Text GenerationIFEval (0-Shot)strict accuracy33.360
Text GenerationBBH (3-Shot)normalized accuracy19.880
Text GenerationMATH Lvl 5 (4-Shot)exact match3.630
Text GenerationGPQA (0-shot)acc_norm8.050
Text GenerationMuSR (0-shot)acc_norm10.860
Text GenerationMMLU-PRO (5-shot)accuracy14.470
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms