qadence

#!/bin/python
from __future__ import annotations
from pathlib import Path
import numpy as np
import sympy
import torch
DEVICE = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
torch.set_default_device(DEVICE)
torch.manual_seed(42)
from qadence import CNOT, RX, RY, Parameter, QuantumCircuit, chain, total_magnetization
from qadence.backends.pyqtorch.backend import Backend as PyQTorchBackend
from qadence.engines.torch.differentiable_backend import DifferentiableBackend
from qadence.logger import get_script_logger
logger = get_script_logger("diff_backend")
def circuit(n_qubits):
    """Helper function to make an example circuit."""
    x = Parameter("x", trainable=False)
    theta = Parameter("theta")
    fm = chain(RX(0, 3 * x), RY(1, sympy.exp(x)), RX(0, theta), RY(1, np.pi / 2))
    ansatz = CNOT(0, 1)
    block = chain(fm, ansatz)
    circ = QuantumCircuit(n_qubits, block)
    return circ
if __name__ == "__main__":
    torch.manual_seed(42)
    n_qubits = 2
    batch_size = 5
    logger.info(f"Running example {Path(__file__).name} with n_qubits = {n_qubits}")
    # Making circuit with AD
    circ = circuit(n_qubits)
    observable = total_magnetization(n_qubits=n_qubits)
    quantum_backend = PyQTorchBackend()
    diff_backend = DifferentiableBackend(quantum_backend, diff_mode="ad")
    diff_circ, diff_obs, embed, params = diff_backend.convert(circ, observable)
    # Running for some inputs
    values = {"x": torch.rand(batch_size, requires_grad=True)}
    wf = diff_backend.run(diff_circ, embed(params, values))
    expval = diff_backend.expectation(diff_circ, diff_obs, embed(params, values))
    dexpval_x = torch.autograd.grad(
        expval, values["x"], torch.ones_like(expval), create_graph=True

from __future__ import annotations
from pathlib import Path
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import optax
from jax import Array, jit, value_and_grad
from numpy.typing import ArrayLike
from qadence import (
    AnalogInteraction,
    AnalogRX,
    AnalogRY,
    AnalogRZ,
    FeatureParameter,
    Register,
    VariationalParameter,
    Z,
    chain,
    hamiltonian_factory,
)
from qadence.backends import backend_factory
from qadence.circuit import QuantumCircuit
from qadence.logger import get_script_logger
from qadence.types import BackendName, DiffMode
logger = get_script_logger("horqrux_analog")
N_QUBITS = 4
N_EPOCHS = 200
BACKEND_NAME = BackendName.HORQRUX
DIFF_MODE = DiffMode.AD
logger.info(f"Running example {Path(__file__).name} with n_qubits = {N_QUBITS}")
bknd = backend_factory(BACKEND_NAME, DIFF_MODE)
register = Register.line(N_QUBITS, spacing=8.0)
# The input feature phi for the circuit to learn f(x)
phi = FeatureParameter("phi")
# Feature map with a few global analog rotations
fm = chain(
    AnalogRX(phi),
    AnalogRY(2 * phi),
    AnalogRZ(3 * phi),
)

from __future__ import annotations
from pathlib import Path
import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt
import optax
from jax import Array, grad, jit, value_and_grad, vmap
from numpy.random import uniform
from numpy.typing import ArrayLike
from qadence.backends import backend_factory
from qadence.blocks.utils import chain
from qadence.circuit import QuantumCircuit
from qadence.constructors import feature_map, hea, ising_hamiltonian
from qadence.logger import get_script_logger
from qadence.types import BackendName, BasisSet, DiffMode
logger = get_script_logger("Horqrux DQC")
N_QUBITS, DEPTH, LEARNING_RATE, N_POINTS = 4, 3, 0.01, 20
logger.info(f"Running example {Path(__file__).name} with n_qubits = {N_QUBITS}")
# building the DQC model
ansatz = hea(n_qubits=N_QUBITS, depth=DEPTH)
# the input data is encoded via a feature map
fm = feature_map(n_qubits=N_QUBITS, param="x", fm_type=BasisSet.CHEBYSHEV)
# choosing a cost function
obs = ising_hamiltonian(n_qubits=N_QUBITS)
# building the circuit and the quantum model
circ = QuantumCircuit(N_QUBITS, chain(fm, ansatz))
bknd = backend_factory(BackendName.HORQRUX, DiffMode.AD)
conv_circ, conv_obs, embedding_fn, params = bknd.convert(circ, obs)
optimizer = optax.adam(learning_rate=LEARNING_RATE)
opt_state = optimizer.init(params)
def exp_fn(params: dict[str, Array], inputs: dict[str, Array]) -> ArrayLike:
    return bknd.expectation(conv_circ, conv_obs, embedding_fn(params, inputs))
# define a problem-specific MSE loss function
# for the ODE df/dx=4x^3+x^2-2x-1/2
def loss_fn(params: dict[str, Array], x: Array) -> Array:
    def loss(x: float) -> Array:
        dfdx = grad(lambda x: exp_fn(params, {"x": x}))(x)
        ode_loss = dfdx - (4 * x**3 + x**2 - 2 * x - 0.5)
        boundary_loss = exp_fn(params, {"x": jnp.zeros_like(x)}) - jnp.ones_like(x)
        return jnp.power(ode_loss, 2) + jnp.power(boundary_loss, 2)