Hanzo ML

use hanzo_ml::{Device, Tensor, DType};

fn main() -> hanzo_ml::Result<()> {
    let device = Device::cuda_if_available(0)?;

    let a = Tensor::randn(0f32, 1., (2, 3), &device)?;
    let b = Tensor::randn(0f32, 1., (3, 4), &device)?;
    let c = a.matmul(&b)?;
    println!("Shape: {:?}", c.shape()); // [2, 4]

    let d = a.relu()?;
    let e = a.softmax(1)?;
    let f = a.to_dtype(DType::BF16)?;

    Ok(())
}

use hanzo_ml::{Device, Tensor, DType, Module};
use hanzo_nn::{VarBuilder, VarMap, Linear, linear, AdamW};

fn main() -> hanzo_ml::Result<()> {
    let device = Device::cuda_if_available(0)?;
    let varmap = VarMap::new();
    let vb = VarBuilder::from_varmap(&varmap, DType::F32, &device);

    let layer1 = linear(784, 256, vb.pp("layer1"))?;
    let layer2 = linear(256, 10, vb.pp("layer2"))?;

    let input = Tensor::randn(0f32, 1., (32, 784), &device)?;
    let h = layer1.forward(&input)?.relu()?;
    let output = layer2.forward(&h)?;

    let mut opt = AdamW::new(varmap.all_vars(), Default::default())?;
    let target = Tensor::zeros((32, 10), DType::F32, &device)?;
    let loss = hanzo_nn::loss::mse(&output, &target)?;
    opt.backward_step(&loss)?;

    println!("Loss: {}", loss.to_scalar::<f32>()?);
    Ok(())
}

use hanzo_ml::quantized::gguf_file;
use std::fs::File;

fn main() -> anyhow::Result<()> {
    let mut file = File::open("model.gguf")?;
    let model = gguf_file::Content::read(&mut file)?;

    for (name, info) in model.tensor_infos.iter() {
        println!("{}: {:?}", name, info.shape);
    }
    Ok(())
}

use hanzo_ml::{Device, DType};
use hanzo_nn::VarBuilder;

let device = Device::cuda_if_available(0)?;
let vb = unsafe {
    VarBuilder::from_mmaped_safetensors(
        &["model.safetensors"], DType::F32, &device,
    )?
};
let weight = vb.get((768, 768), "transformer.h.0.attn.c_attn.weight")?;

[dependencies]
# From crates.io (when published)
hanzo-ml = { version = "0.9.2-alpha.2", features = ["metal"] }
hanzo-nn = "0.9.2-alpha.2"
hanzo-transformers = "0.9.2-alpha.2"

# From git (current)
hanzo-ml = { git = "https://github.com/hanzoai/ml", branch = "main" }
hanzo-nn = { git = "https://github.com/hanzoai/ml", branch = "main" }
hanzo-transformers = { git = "https://github.com/hanzoai/ml", branch = "main" }

# In engine Cargo.toml
[dependencies]
hanzo-ml = { git = "https://github.com/hanzoai/ml", branch = "main" }
hanzo-nn = { git = "https://github.com/hanzoai/ml", branch = "main" }
hanzo-transformers = { git = "https://github.com/hanzoai/ml", branch = "main" }

[features]
default = ["metal"]
metal = ["hanzo-ml/metal", "hanzo-nn/metal"]
cuda = ["hanzo-ml/cuda"]

ml/
├── hanzo-ml/                 # Core tensor ops (hanzo-branded)
│   ├── src/
│   │   ├── lib.rs
│   │   ├── tensor.rs         # Tensor type
│   │   ├── device.rs         # CPU/CUDA/Metal device
│   │   ├── dtype.rs          # Data types (F16, BF16, F32, etc.)
│   │   ├── backend.rs        # Backend trait
│   │   ├── cuda_backend/     # CUDA implementation
│   │   ├── metal_backend/    # Metal implementation
│   │   ├── cpu_backend/      # CPU implementation
│   │   ├── quantized/        # GGUF/GGML quantization
│   │   └── safetensors.rs    # safetensors loading
│   ├── benches/              # Performance benchmarks
│   └── tests/                # Unit tests
├── hanzo-nn/                 # Neural network layers
├── hanzo-transformers/       # 90+ transformer model implementations
├── hanzo-datasets/           # Dataset loading utilities
├── hanzo-ml-pyo3/            # Python bindings
├── hanzo-flash-attn/         # Flash Attention CUDA kernels
│   └── kernels/              # CUDA kernel source files
├── hanzo-metal-kernels/      # Metal GPU kernels
├── hanzo-kernels/            # Generic CUDA kernels
├── hanzo-onnx/               # ONNX evaluation
├── hanzo-ml-examples/        # Example binaries
├── hanzo-ml-wasm-examples/   # WASM browser examples
├── candle-core/              # Upstream-compatible core (v0.9.2)
├── candle-nn/                # Upstream-compatible NN
├── candle-transformers/      # Upstream-compatible transformers
├── candle-datasets/          # Upstream-compatible datasets
├── candle-examples/          # Upstream-compatible examples
├── candle-book/              # Documentation book
├── tensor-tools/             # CLI tensor manipulation
├── Cargo.toml                # Workspace root
├── Makefile
├── HANZO_INTEGRATION.md      # Engine integration guide
└── LLM.md

# Build entire workspace
cargo build --workspace

# Test everything
cargo test --workspace

# Build with Metal (Apple Silicon)
cargo build --workspace --features metal

# Build with CUDA
cargo build --workspace --features cuda

# Run example (LLaMA inference)
cargo run --release --example llama -- --model meta-llama/Llama-3.2-3B-Instruct

# Sync from upstream
git remote add upstream https://github.com/huggingface/candle.git
git fetch upstream
git merge upstream/main