# System Requirements for TimesFM 2.5: Hardware Tiers and Memory Configuration

> Explore TimesFM 2.5 system requirements across four hardware tiers. Understand memory needs from CPU-only to GPU setups for efficient model deployment.

- Repository: [Google Research/timesfm](https://github.com/google-research/timesfm)
- Tags: system-requirements
- Published: 2026-04-02

---

**TimesFM 2.5 supports four hardware tiers ranging from 4 GB CPU‑only environments to production‑grade GPUs with 16 GB+ VRAM, with total memory requirements calculated as approximately 800 MB for model weights plus 0.5 GB overhead and 0.2 MB per 1,000 series per context point.**

TimesFM 2.5 is a 200 million‑parameter time‑series forecasting model developed by Google Research. Understanding the system requirements for TimesFM 2.5 is essential before deployment, as the model’s memory footprint scales linearly with context length and batch size. The `google-research/timesfm` repository provides a pre‑flight validation tool and detailed hardware tier specifications in [`timesfm-forecasting/references/system_requirements.md`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/references/system_requirements.md) to help you match your infrastructure to your forecasting workload.

## Hardware Tiers for TimesFM 2.5

The repository defines four distinct hardware tiers in the official requirements file. Each tier specifies RAM or VRAM minimums, recommended batch sizes (`per_core_batch_size`), and maximum context lengths (`max_context`).

### Tier 1 – Minimal (CPU‑only)

**Target Hardware**: CPU with 4 – 8 GB RAM.  
**Configuration**: Set `per_core_batch_size=4` and `max_context=512`.  
**Performance**: Processes 100‑point series in 2 – 5 seconds.  
**Memory Profile**: Requires approximately 100 MB per 1,000 series for 512‑point contexts according to the memory formula in [`system_requirements.md`](https://github.com/google-research/timesfm/blob/main/system_requirements.md).

### Tier 2 – Standard (CPU or GPU)

**Target Hardware**: CPU with ≥ 16 GB RAM **or** GPU with 4 – 8 GB VRAM.  
**Configuration**: Use `per_core_batch_size=32` on CPU or `per_core_batch_size=64` on GPU, with `max_context=1024`.  
**Performance**: GPU inference typically completes in 0.5 – 1 second for 100‑point series.  
**Memory Profile**: 1,024‑point contexts require ~200 MB per 1,000 series.

### Tier 3 – Production (High‑End GPU)

**Target Hardware**: GPU with ≥ 16 GB VRAM **or** Apple Silicon with ≥ 32 GB unified memory.  
**Configuration**: Set `per_core_batch_size` between `128` and `256`, with `max_context=4096` or higher.  
**Performance**: Typical inference speed of 0.1 – 0.3 seconds per 100‑point series.  
**Memory Profile**: Contexts of 4,096 points require substantial VRAM; the absolute maximum of 16,384 points demands significant memory resources.

### Tier 4 – Legacy Models (TimesFM 2.0)

**Target Hardware**: CPU with ≥ 16 GB RAM **or** GPU with ≥ 8 GB VRAM.  
**Configuration**: Applies to the legacy 500 M‑parameter TimesFM 2.0 model.  
**Notes**: This tier supports the earlier model architecture with higher baseline memory requirements than the 200 M‑parameter TimesFM 2.5.

## Memory Calculation Formula

The canonical memory estimation formula is documented in [`timesfm-forecasting/references/system_requirements.md`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/references/system_requirements.md) (lines 12‑20):

```text
RAM ≈ model_weights + 0.5 GB + (0.2 MB × num_series × context_length / 1000)

```

- **`model_weights`**: Approximately 800 MB for TimesFM 2.5.
- **`context_length`**: Defined by the `max_context` parameter in your `ForecastConfig`.
- **`num_series`**: Number of time‑series processed in a single batch.

Larger contexts are feasible but require proportionally more memory. For example, 2,048‑point contexts typically require ~16 GB RAM, while 4,096‑point contexts need a GPU or ≥ 32 GB RAM.

## Pre‑Flight System Validation

Before executing training or inference, run the **pre‑flight system checker** located at [`timesfm-forecasting/scripts/check_system.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/check_system.py). This script evaluates your machine’s RAM and VRAM against the selected tier and prints warnings if the configuration exceeds available resources, preventing out‑of‑memory crashes.

```bash
python -m timesfm-forecasting.scripts.check_system \
    --max_context 1024 \
    --per_core_batch_size 64

```

The checker reads hardware specifications and confirms whether your requested `max_context` and batch size fit within the limits defined for your hardware tier. For a complete example of tier‑specific configuration in practice, see [`timesfm-forecasting/scripts/forecast_csv.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/forecast_csv.py).

## Configuration Examples by Hardware Tier

The following `ForecastConfig` implementations correspond to the hardware tiers defined in the system requirements file and are implemented in the core Torch backend at [`src/timesfm/timesfm_2p5/timesfm_2p5_torch.py`](https://github.com/google-research/timesfm/blob/main/src/timesfm/timesfm_2p5/timesfm_2p5_torch.py).

### Minimal Tier Configuration

For Tier 1 (CPU‑only, 4 – 8 GB RAM) as specified in lines 35‑41 of the requirements file:

```python
import timesfm
model = timesfm.ForecastConfig(
    max_context=512,
    max_horizon=128,
    per_core_batch_size=4,
    normalize_inputs=True,
    use_continuous_quantile_head=True,
    fix_quantile_crossing=True,
)
model.compile()

```

### Standard Tier GPU Configuration

For Tier 2 (GPU with 4 – 8 GB VRAM) as specified in lines 54‑61:

```python
import timesfm
model = timesfm.ForecastConfig(
    max_context=1024,
    max_horizon=256,
    per_core_batch_size=64,   # GPU batch size

    normalize_inputs=True,
    use_continuous_quantile_head=True,
    fix_quantile_crossing=True,
)
model.compile()

```

### Production Tier Configuration

For Tier 3 (GPU with ≥ 16 GB VRAM) as specified in lines 73‑80:

```python
import timesfm
model = timesfm.ForecastConfig(
    max_context=4096,
    max_horizon=256,
    per_core_batch_size=128,  # or 256 for very large batches

    normalize_inputs=True,
    use_continuous_quantile_head=True,
    fix_quantile_crossing=True,
)
model.compile()

```

## Summary

- **TimesFM 2.5** defines four hardware tiers from minimal 4 GB CPU setups to production 16 GB+ GPU environments.
- **Memory requirements** scale according to the formula `RAM ≈ 800 MB + 0.5 GB + (0.2 MB × num_series × context_length / 1000)`.
- **Context limits** vary by tier: 512 points (Minimal), 1,024 points (Standard), and up to 4,096+ points (Production).
- **Validation tool**: Use [`timesfm-forecasting/scripts/check_system.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/check_system.py) to verify your hardware against configuration parameters before running inference.
- **Reference documentation**: Canonical specifications live in [`timesfm-forecasting/references/system_requirements.md`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/references/system_requirements.md).

## Frequently Asked Questions

### Can TimesFM 2.5 run on a CPU without a GPU?

Yes. The **Minimal tier** supports CPU‑only operation with 4 – 8 GB RAM using `max_context=512` and `per_core_batch_size=4`. The **Standard tier** also supports CPU operation with ≥ 16 GB RAM, though GPU acceleration significantly improves inference speed.

### How much RAM is required for a context length of 4096 points?

A context length of 4,096 points requires the **Production tier** hardware: either a GPU with ≥ 16 GB VRAM or Apple Silicon with ≥ 32 GB unified memory. According to the memory formula, this context length demands substantial memory allocation proportional to the batch size.

### What is the `per_core_batch_size` parameter and how does it affect memory?

The `per_core_batch_size` parameter controls how many time‑series are processed simultaneously per core. Higher values increase throughput but linearly increase RAM consumption based on the formula `0.2 MB × num_series × context_length / 1000`. The Minimal tier uses `4`, Standard uses `32`–`64`, and Production uses `128`–`256`.

### Where can I find the official system requirements documentation?

The canonical hardware specifications and memory formulas are documented in [`timesfm-forecasting/references/system_requirements.md`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/references/system_requirements.md) within the `google-research/timesfm` repository. The companion validation script is located at [`timesfm-forecasting/scripts/check_system.py`](https://github.com/google-research/timesfm/blob/main/timesfm-forecasting/scripts/check_system.py).