gala-python-interop

Files (1)

• SKILL.md

SKILL.md (first lines)

## Task

$ARGUMENTS

## Overview

Gala provides **Python interoperability** via PyO3. Call Gala kernels from Python for incremental adoption in ML pipelines.

## Installation

```bash
# Install Gala Python package (when available)
pip install gala-lang

# Or build from source
cd tools/gala-python
maturin develop --release
```

## Basic Usage

```python
import gala
import numpy as np

# Compile Gala code from string
kernel = gala.compile("""
fn bell() -> Qubits<2> quantum {
    let a = qubit()
    let b = qubit()
    h(a)
    cx(a, b)
    (a, b)
}
""")

# Run on simulator
result = kernel.run(backend="simulator", shots=1000)
print(result)  # Measured distribution
```

## PyTorch Integration

```python
import torch
import gala

# Gala variational layer as PyTorch module
class GalaVQLayer(torch.nn.Module):
    def __init__(self, n_qubits: int, depth: int):
        super().__init__()
        self.n_qubits = n_qubits
        self.depth = depth
        
        # Gala parameters as PyTorch parameters
        self.theta = torch.nn.Parameter(
            torch.randn(depth, n_qubits) * 0.1
        )
        
        # Compile Gala circuit
        self.circuit = gala.compile(f"""
        import gala.vqa.{{angle_encode, layered_ansatz}}
        
        fn circuit(x: Vec<Float>, θ: Params) -> Measured<Float> prob {{
            let q = angle_encode(qubits<{n_qubits}>(), x)
            layered_ansatz(q, θ, depth: {depth})
            // Measure expectation of Z on first qubit
            let m = measure(q[0])
            // Convert to expectation: P(0) - P(1)
            Measured<Float>::new(if m {{ -1.0 }} else {{ 1.0 }})
        }}
        """)
    
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: [batch, n_qubits]
        # theta: [depth, n_qubits]
        results = []
        for i in range(x.shape[0]):
            result = self.circuit.run(
                backend="simulator",
                shots=1000,
                x=x[i].detach().numpy(),
                theta=self.theta.detach().numpy()
            )
            results.append(result.expectation())
        return torch.tensor(results, dtype=torch.float32)

# Use in PyTorch model
class HybridModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.classical = torch.nn.Sequential(
            torch.nn.Linear(784, 256),
            torch.nn.ReLU(),
            torch.nn.Linear(256, 4)  # 4 qubits
        )
        self.quantum = GalaVQLayer(4, 3)
        self.output = torch.nn.Linear(1, 10)
    
    def forward(self, x):
        x = self.classical(x)
        x = self.quantum(x)  # Quantum layer
        x = self.output(x)
        return x

# Train end-to-end!
model = HybridModel()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(100):
    for batch_x, batch_y in dataloader:
        optimizer.zero_grad()
        pred = model(batch_x)
        loss = torch.nn.functional.cross_entropy(pred, batch_y)
        loss.backward()
        optimizer.step()
```

## NumPy Arrays

From gala-pl/gala, Apache-2.0.

More from gala-pl/gala