pytorch 2.8 release

# auto-detect backend (cuda if available, cpu otherwise)
uv pip install torch --torch-backend=auto
uv pip install torchvision torchao  # then add related packages

# or for project setup with specific backend
uv init my-project
cd my-project
uv add torch torchvision --index https://download.pytorch.org/whl/cu128  # cuda 12.8
uv add torchao  # add after torch is configured

# cpu
pip install torch==2.8.0 torchao --index-url https://download.pytorch.org/whl/cpu

# cuda 12.8 (recommended)
pip install torch==2.8.0 torchao --index-url https://download.pytorch.org/whl/cu128

# cuda 12.6 (for older gpus: maxwell, pascal, volta)
pip install torch==2.8.0 torchao --index-url https://download.pytorch.org/whl/cu126

from torchao.float8 import convert_to_float8_training

# convert model to float8
model = convert_to_float8_training(model)

# results: 1.5x faster training on llama-3.1-70b

model = torch.compile(model, mode="reduce-overhead")
# better handling of nested control flow
# reduced compilation time for large models

from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torchao.quantization import quantize_

# quantize then distribute
quantize_(model, int8_weight_only())
model = FSDP(model)

from torchao.quantization import quantize_, int8_weight_only

# quantize model for intel cpu (int8 works on cpu)
quantize_(model, int8_weight_only())

# note: int4_weight_only() requires cuda backend
# intel cpu optimizations focus on int8 quantization
# performance on 6th gen xeon (32 cores):
# - llama-3.1-8b: 20% latency reduction with quantization

# cpu-compatible quantization

# 8-bit weights only (works on cpu)
from torchao.quantization import int8_weight_only
quantize_(model, int8_weight_only())

# dynamic 8-bit activations, 8-bit weights (works on cpu)
from torchao.quantization import int8_dynamic_activation_int8_weight
quantize_(model, int8_dynamic_activation_int8_weight())

# cuda-only quantization

# 4-bit weights (requires cuda - not cpu compatible)
from torchao.quantization import int4_weight_only
model = model.cuda()
quantize_(model, int4_weight_only())  # cuda only

# previously: only for batch_size >= 16
# now: benefits when batch_size > 4

# enable max-autotune for best performance
torch._inductor.config.max_autotune = True

# note: requires intel 4th gen xeon or newer with amx support
# check cpu features: grep amx /proc/cpuinfo

device = torch.device("mps")
model = model.to(device)
compiled_model = torch.compile(model)
# first compilation support for m-series chips

# for older gpus
pip install torch==2.8.0 --index-url https://download.pytorch.org/whl/cu126

# old (deprecated)
from torch.ao.quantization import quantize_dynamic

# new
from torchao.quantization import quantize_

# before (2.7)
import torch.ao.quantization as quant
model = quant.quantize_dynamic(model, {torch.nn.Linear})

# after (2.8) - tested and working
from torchao.quantization import quantize_, int8_dynamic_activation_int8_weight
quantize_(model, int8_dynamic_activation_int8_weight())

import torch
from torchao.quantization import quantize_, int8_weight_only

# create model
model = torch.nn.Sequential(
    torch.nn.Linear(128, 64),
    torch.nn.ReLU(),
    torch.nn.Linear(64, 32)
)

# quantize for cpu inference
quantize_(model, int8_weight_only())

# run inference
x = torch.randn(32, 128)
output = model(x)  # works on cpu

import torch

# check cuda support
if torch.cuda.is_available():
    capability = torch.cuda.get_device_capability()
    device_name = torch.cuda.get_device_name(0)
    print(f"gpu: {device_name}, compute capability: {capability}")

    if capability[0] < 8:  # volta (7.x) or older
        print("warning: use cuda 12.6 for maxwell/pascal/volta gpus")
        print("cuda 12.8+ drops support for compute capability < 8.0")
else:
    print("cuda not available - cpu quantization only (int8)")

# check cpu features (linux)
import subprocess
try:
    result = subprocess.run(['grep', 'flags', '/proc/cpuinfo'],
                          capture_output=True, text=True)
    has_amx = 'amx' in result.stdout
    has_avx512 = 'avx512' in result.stdout
    print(f"cpu has amx: {has_amx}, avx512: {has_avx512}")
except:
    pass  # windows/mac

# new compilation options
torch._inductor.config.max_autotune = True  # enable amx optimizations
torch._inductor.config.use_mixed_mm = True  # mixed precision matmul