quark-install

Files (1)

• SKILL.md

SKILL.md (first lines)

# quark-install

## Purpose

Install the AMD Quark package and its dependencies after PyTorch is already set up. This skill handles Quark-specific setup: the `amd-quark` package, core dependencies, optional ONNX Runtime, LLM PTQ extras, and compiler requirements. It exists separately from `quark-torch-install` (which handles PyTorch) and from PTQ planning because getting the environment right is a prerequisite — a missing dependency or wrong compiler will cause cryptic failures later.

## Inputs

- `env_context.json` for OS/Python/accelerator facts
- `pytorch_install_result.json` confirming PyTorch is installed and verified

## Outputs: quark_install_result.json

Records the installed Quark version, optional extras (ONNX runtime, LLM PTQ deps), and verification status.

Schema: [`quark_install_result.schema.json`](../../../shared/contracts/quark_install_result.schema.json)

```json
{
  "status": "ok",
  "quark_version": "0.12",
  "install_source": "pypi",
  "extras_installed": {
    "onnxruntime": false,
    "llm_ptq_deps": true
  },
  "verification": {
    "import_ok": true,
    "kernel_ok": true,
    "onnx_ops_ok": null
  }
}
```

On failure, set `status: "failed"` and include a `failure_reason` with the exact failing verification command.

## Quark Package Info

- **PyPI package**: `amd-quark` (current version: 0.12)
- **Install from PyPI (universal wheel, recommended default)**: `pip install amd-quark`. Works on any OS/Python/accelerator regardless of PyTorch version, but compiles the fast quantization kernels and ONNX custom-op library on first import (requires a C++ compiler, plus `nvcc`/`hipcc` for GPU).
- **Install a pre-built wheel (optional, PyTorch 2.10+)**: ships pre-compiled C++ extensions, so no C++ compiler and no first-run compilation are needed. Hosted on the AMD package index (Python 3.11–3.13); point `pip` at the matching index:

  ```bash
  pip install amd-quark --extra-index-url https://pypi.amd.com/quark/cpu/simple     # CPU
  pip install amd-quark --extra-index-url https://pypi.amd.com/quark/cu128/simple   # CUDA 12.8
  pip install amd-quark --extra-index-url https://pypi.amd.com/quark/rocm71/simple  # ROCm 7.1, Linux only
  pip install amd-quark --extra-index-url https://pypi.amd.com/quark/rocm72/simple  # ROCm 7.2, Linux only
  ```

- **Install from source**:

  ```bash
  git clone --recursive https://github.com/AMD/Quark
  cd Quark
  git submodule sync && git submodule update --init --recursive
  pip install .
  ```

- **Install from wheel**: `pip install amd_quark*.whl`

## Python Version Requirements

- **Supported**: Python 3.11, 3.12, 3.13
- **Not supported**: Python 3.14+
- **Recommended for new setups**: Python 3.13 via Miniforge/Miniconda

## ONNX Runtime (Optional)

- Version constraint: `>=1.22.2, <=1.24.2`
- GPU variant: `pip install onnxruntime-gpu` (for CUDA)
- CPU variant: `pip install onnxruntime`
- ROCm note: use the CPU variant of ONNX Runtime for ROCm 7.0+ due to build compatibility issues

## LLM PTQ Additional Dependencies

For running `quantize_quark.py`, install these extras:

```bash
pip install accelerate datasets evaluate>=0.4.0 gguf>=0.10.0 lm-eval transformers<5.3
```

## Core Dependencies (from requirements.txt)

```text
evaluate, joblib, ninja, numpy>=2.0, onnx>=1.21.0,<=1.22.0, onnxscript,
onnxslim>=0.1.84, pandas, plotly, protobuf, psutil, pydantic, rich, scipy,
sentencepiece, tqdm, zstandard
```

## Compiler Requirements

- **Linux**: `sudo apt install build-essential` (includes g++, needed for kernel compilation)
- **Windows**: Visual Studio 2022+ with "Desktop development with C++" workload

## Rules

- **Ensure PyTorch is already installed and verified.** If PyTorch is missing or mismatched with the accelerator, hand off to `quark-torch-install` first. Do not attempt to install Quark without a working PyTorch.
- **Never skip verification.** After installation, always run verification commands.
- **Show exact commands before execution.** The user should see every `pip install` command and every version before anything runs.

## Verification Commands

```bash
# Basic import
python -c "import quark; print('Quark version:', quark.__version__)"

# Optional: kernel compilation test
python -c "import quark.torch.kernel; print('Kernel compilation OK')"

# Optional: ONNX custom ops
python -c "import quark.onnx.operators.custom_ops; print('ONNX custom ops OK')"
```

## Interaction Flow

1. **Intake**: Determine what the user already has installed and what they need. Check if `quark-torch-install` has already run and PyTorch is verified.
2. **Plan**: Present the installation plan as a numbered sequence of commands, with version justifications.
3. **Confirm**: Required before any package installation. Show: what will be installed and what environment will be modified.
4. **Execute**: Run the installation commands.

From amd/Quark, MIT.

More from amd/Quark