AMD Instinct MI450X

AMD Instinct MI450X
AMD Instinct MI450X graphics card review

AMD Instinct MI450X - a server accelerator with 288 GB of HBM4 for Helios racks

On November 12, 2026, AMD introduced the Instinct MI450X, a server GPU from the MI400 series for training neural networks and running trained models. The accelerator is built as a module with direct liquid cooling. An AMD Helios rack accommodates 72 of these GPUs.

The MI450X has eight HBM4 stacks with a total capacity of 288 GB. The higher-end MI455X has twelve stacks and 432 GB. Both models are based on the CDNA 5 architecture. AMD specifies the same peak compute performance and memory bandwidth of up to 23.3 TB/s for both. Less is currently known about the MI450X's performance on DeepSeek-R1: the result published at launch refers to the MI455X. The difference in memory capacity can already be assessed using the model's weights and cache.

Will DeepSeek-R1 fit on a single MI450X?

The main DeepSeek-R1 model contains approximately 671 billion parameters without the additional multi-token prediction (MTP) module. When processing a single token, approximately 37 billion parameters are used. The model may select different experts for the next token, so loading the model fully into GPU memory requires the weights of all experts.

With ideal packing at four bits per parameter, the weights alone would occupy approximately 335.5 GB, or 312.5 GiB. This is a lower estimate that excludes metadata and other overhead. Even if the advertised 288 GB is interpreted as 288 GiB, the weights would still require more than one MI450X. The MI455X's nominal capacity is sufficient for the weights themselves under both interpretations of the units. Running the model also requires workspace buffers and memory for the context.

The storage format has a noticeable effect on the calculation. In MXFP4, every 32 four-bit values require one byte for a shared scale. Packing all 671 billion parameters in this format would result in approximately 356.5 GB, or 332 GiB. The actual size also depends on which layers a particular implementation retains at higher precision.

The context also consumes memory. For example, with DeepSeek-R1's compact MLA cache in BF16, a single request containing 131,072 tokens requires approximately 9.2 GB of cache data. This calculation covers 61 layers and excludes program overhead. It indicates the approximate cost of a long conversation, but determining the number of simultaneous requests requires a measurement on a running server.

When 288 GB is enough

  • A model with 70 billion parameters requires approximately 140 GB for its weights in BF16. A single MI450X has room left for the cache and workspace buffers. If that is sufficient for the required context length, the remaining GPUs can serve separate copies of the model.
  • With a large number of long conversations, a server may run out of memory for the cache. In that case, the MI455X's additional HBM4 allows it to handle more requests simultaneously.
  • When a model and its cache fit on one GPU, deployment is simpler: that copy does not require data exchange between accelerators. Maximum throughput under load is a separate question. Distributing computation across multiple GPUs can be beneficial even when one accelerator has enough memory.

What the DeepSeek-R1 tests show

In the MLPerf Inference Offline scenario, the system receives all requests at once. The test measures the total output-token generation rate. For the MI455X, AMD's lab published a result already converted to a per-GPU figure. For NVIDIA systems, the average in the last column is calculated by dividing the system result by the number of accelerators.

System Result source Number of GPUs Offline, tokens/s per system Offline, tokens/s per GPU
AMD Helios with Instinct MI450X No data as of November 18, 2026 - - -
AMD Helios with Instinct MI455X AMD internal test Not specified - 21,333
NVIDIA Vera Rubin NVL72 MLPerf v6.1 Closed, Preview 72 1,183,327 16,435
Nebius, NVIDIA GB300 NVL72 MLPerf v6.1 Closed 72 689,961 9,583
Nebius, NVIDIA HGX B300 MLPerf v6.1 Closed 8 69,655 8,707

AMD compared its own result of 21,333 tokens/s on the MI455X with the Vera Rubin NVL72 result from the Preview category. The difference between the published figures is approximately 30%. AMD's measurement was not validated by MLCommons. The announcement also does not specify the number of GPUs used or the numerical format for the calculations. These figures cannot establish what the advantage would be under identical conditions.

Results with latency constraints are also available for the Vera Rubin NVL72. In MLPerf Server, the 72-GPU rack achieved 1,175,890 tokens/s; in Interactive, it achieved 652,750 tokens/s. Interactive has stricter requirements: up to 1.5 seconds to the first token and up to 15 ms for each subsequent token. These are test thresholds. AMD's announcement does not include comparable Server or Interactive results for the MI450X or MI455X.

How to choose between the MI450X and MI455X

The practical advantage of 432 GB will become apparent if the additional memory allows a model copy to be placed on fewer GPUs or allows more requests to be served at the required latency. The cost per million output tokens should be compared for the entire configuration with the model and workload held constant. AMD did not disclose Helios pricing in the announcement, so it is not yet possible to determine which configuration offers better value based on the published results.

GPU Comparison

Compare Instinct MI450X with other GPUs

Please select GPU from the dropdown list.

Basic

Label Name
AMD
Platform
Professional
Launch Date
November 2026
Accelerated Compute Dies (XCD)
8
Cooling
Direct Liquid Cooling
Form Factor
EAM
GPU Lithography
TSMC 2nm / 3nm FinFET
I/O Dies (IOD)
2
Model Name
AMD Instinct MI450X
Generation
Instinct MI400 Series
Boost Clock
2400 MHz
Transistors
320 billion
Compute Units
256
Foundry
TSMC
Process Size
2nm / 3nm FinFET
Architecture
CDNA 5

Memory Specifications

HBM Memory Stacks
8
Memory ECC
Yes
Memory Partitions
4
Memory Size
288 GB
Memory Type
HBM4
Bandwidth
Memory bandwidth refers to the data transfer rate between the graphics chip and the video memory. It is measured in bytes per second, and the formula to calculate it is: memory bandwidth = working frequency × memory bus width / 8 bits.
23.3 TB/s

Display and Media

AV1 Encode/Decode
AV1 decode (4 shared engines)
H.264 Hardware Encode/Decode
H.264 decode (4 shared engines)
H.265 HEVC Hardware Encode/Decode
H.265 decode (4 shared engines)
JPEG/MJPEG Codec Cores
40
Video Decoder Engines
4 shared engines (H.264, H.265, VP9, AV1)

Theoretical Performance

FP32 Matrix
315 TFLOPS
FP32 Vector
315 TFLOPS
FP16 (half)
An important metric for measuring GPU performance is floating-point computing capability. Half-precision floating-point numbers (16-bit) are used for applications like machine learning, where lower precision is acceptable. Single-precision floating-point numbers (32-bit) are used for common multimedia and graphics processing tasks, while double-precision floating-point numbers (64-bit) are required for scientific computing that demands a wide numeric range and high accuracy.
315 TFLOPS
FP64 (double)
An important metric for measuring GPU performance is floating-point computing capability. Double-precision floating-point numbers (64-bit) are required for scientific computing that demands a wide numeric range and high accuracy, while single-precision floating-point numbers (32-bit) are used for common multimedia and graphics processing tasks. Half-precision floating-point numbers (16-bit) are used for applications like machine learning, where lower precision is acceptable.
5 TFLOPS
FP32 (float)
An important metric for measuring GPU performance is floating-point computing capability. Single-precision floating-point numbers (32-bit) are used for common multimedia and graphics processing tasks, while double-precision floating-point numbers (64-bit) are required for scientific computing that demands a wide numeric range and high accuracy. Half-precision floating-point numbers (16-bit) are used for applications like machine learning, where lower precision is acceptable.
315 TFLOPS

AI Features

AI Software Frameworks Supported by GPU
PyTorch, TensorFlow, JAX, ONNX Runtime, SGLang, Triton, Kokkos, RAJA
BF16 Matrix
5033 TFLOPS
BF16 Matrix Sparse
10066 TFLOPS
FP16 Matrix
5033 TFLOPS
FP16 Matrix Sparse
10066 TFLOPS
FP8 Matrix
20133 TFLOPS
INT8 Matrix
5033 TOPS
INT8 Matrix Sparse
10066 TOPS
MXFP4
40265 TFLOPS
MXFP6
20133 TFLOPS
MXFP8
20133 TFLOPS

Interconnect and Scalability

CPU-to-GPU Interconnect
256 GB/s
GPU Interconnect
UALink / UALoE
Scale-out Bandwidth
600 GB/s
Scale-up Bandwidth
3.6 TB/s

Miscellaneous

Virtualization
SR-IOV
L2 Cache
192 MB

Benchmarks

FP32 (float)
Score
315 TFLOPS

Compared to Other GPU

FP32 (float) / TFLOPS
115.15 -63.4%
91.375 -71%
80.086 -74.6%
66.228 -79%