Know how an LLM will runbefore you run it.

Real MI300X measurements, prediction models and a hardware planner, together in one open research lab.

…Measured configurations

…Models tested

…Precision modes

…MI300X memory recorded

Model size is only the start.

Precision, context length and backend each move the operating envelope. The lab pairs real MI300X measurements with predictive modeling so you can see VRAM, throughput and hardware fit before you commit to a run.

Open the research workspace

Model size: Loading
Precision: Loading
Context: Loading
Backend: Multiple inference stacks

Built from real measurements.

A read-only view of the benchmark dataset. Every observation keeps its source, so you can tell what was run from what was predicted.

Measured–

Peak VRAM across source rows

Measured–

Generation throughput, tokens per second

Open the benchmark explorer

Filter original runs by model, precision, context and backend.

Three ways to read the data.

Model scaling

Compare measured memory and generation speed as parameter count grows.

Explore scaling

Precision

See how quantization and number formats change results across models and backends.

Explore precision

Configuration

Find where context length and backend choice shift the measured performance envelope.

Explore benchmarks

What can your system run?

Start the local API and the lab reads your CPU, RAM and GPU, then compares them against MI300X-calibrated estimates. The hosted site can’t inspect your device, and estimates are not local runtime benchmarks.

Analyze my device

Local device profileNeeds the local app

CPU, RAM, GPU and OS

Detected by FastAPI on your own machine after setup.

GPU memoryLocal probe

System RAMLocal probe

ProcessorLocal probe

Nothing leaves your machine.See setup steps

Measured is not estimated.

Every view labels where a number came from. Predictions can guide where to look next, but they never become benchmark records.

Measured

Direct observation

Values recorded from a real run in the source dataset.

Estimated

Predictor output

Model-based values for a configuration nobody has measured.

Interpolated

Between observations

A derived value supported by neighboring measured cases.

Research you can inspect.

The benchmark dataset, trained predictors, FastAPI service, benchmark tooling and this dashboard are all in the public repository.

Open the repository Enter the lab

Measurements
Predictors
FastAPI
Next.js
Reproducible runs

Run it on your machine.

Four steps from clone to a working lab. Follow the steps below to clone the GitHub repository and run the full environment locally.

Enter the lab GitHub

Clone the repository

git clone https://github.com/VedantJadhav701/AMD_LLM_LAB.git
cd AMD_LLM_LAB

Create a Python environment and install the backend

python -m venv .venv
# Windows: .venv\Scripts\Activate.ps1
# macOS/Linux: source .venv/bin/activate
python -m pip install -r backend/requirements.txt

Python 3.11 is the tested version.

Start the FastAPI service
```
cd backend
uvicorn api.main:app --host 127.0.0.1 --port 8000 --reload
```
API docs open at http://127.0.0.1:8000/docs
Start the dashboard
```
# in a second terminal, from the repository root
cd dashboard
npm install
npm run dev
```
Open http://localhost:3000. The dashboard finds the API on port 8000 by itself.