Amazon Braket

Braket Digital backend

Backend dataclass

Bases: Backend

assign_parameters(circuit, param_values)

Assign numerical values to the circuit parameters.

Source code in qadence/backends/braket/backend.py

def assign_parameters(
    self, circuit: ConvertedCircuit, param_values: dict[str, Tensor | float]
) -> BraketCircuit:
    """Assign numerical values to the circuit parameters."""
    if param_values is None:
        return circuit.native()

    params_copy = param_values.copy()
    pnames = [p.name for p in circuit.native.parameters]

    # account for fixed parameters
    for name in param_values.keys():
        if name not in pnames:
            params_copy.pop(name)

    # make sure that all the parameters are single floats
    # otherwise it won't be accepted by Braket
    native_params = promote_parameters(params_copy)

    # assign the parameters to the circuit
    assigned_circuit = circuit.native(**native_params)

    return assigned_circuit

sample(circuit, param_values={}, n_shots=1, state=None, noise=None, mitigation=None, endianness=Endianness.BIG)

Execute the circuit and return samples of the resulting wavefunction.

Source code in qadence/backends/braket/backend.py

def sample(
    self,
    circuit: ConvertedCircuit,
    param_values: dict[str, Tensor] = {},
    n_shots: int = 1,
    state: Tensor | None = None,
    noise: Noise | None = None,
    mitigation: Mitigations | None = None,
    endianness: Endianness = Endianness.BIG,
) -> list[Counter]:
    """Execute the circuit and return samples of the resulting wavefunction."""
    if state is not None:
        raise NotImplementedError("Braket cannot handle a custom initial state.")

    if n_shots < 1:
        raise ValueError("You can only call sample with n_shots>0.")

    if self.is_remote:
        # handle here, or different backends?
        raise NotImplementedError

    # loop over all values in the batch

    samples = []
    for vals in to_list_of_dicts(param_values):
        final_circuit = self.assign_parameters(circuit, vals)
        task = self._device.run(final_circuit, n_shots)
        samples.append(task.result().measurement_counts)
    if endianness != self.native_endianness:
        from qadence.transpile import invert_endianness

        samples = invert_endianness(samples)
    if noise is not None:
        samples = apply_noise(noise=noise, samples=samples)
    if mitigation is not None:
        logger.warning(
            "Mitigation protocol is deprecated. Use qadence-protocols instead.",
        )
        assert noise
        samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
    return samples