Merge pull request #178 from nwittler/test-update

Update the two qubit test

Author: nwittler

c3/libraries/algorithms.py

@@ -292,7 +292,6 @@ def tf_fun():
     return result
 
 
-@algo_reg_deco
 def tf_adam(
     x_init: np.ndarray,
     fun: Callable = None,
@@ -357,7 +356,6 @@ def tf_rmsprop(
     raise NotImplementedError("This algorithm is not yet implemented.")
 
 
-@algo_reg_deco
 def tf_adadelta(
     x_init: np.ndarray,
     fun: Callable = None,

test/conftest.py

@@ -1,5 +1,8 @@
 import numpy as np
 import tensorflow as tf
+import copy
+import os
+import tempfile
 from typing import Any, Dict, Iterator, Tuple
 from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
 from c3.utils.tf_utils import (
@@ -9,11 +12,28 @@
     super_to_choi,
     tf_project_to_comp,
 )
+from c3.experiment import Experiment
+from c3.model import Model
+from c3.libraries.chip import Qubit, Coupling, Drive
+from c3.signal.pulse import Envelope, Carrier
+from c3.libraries.envelopes import no_drive, gaussian_nonorm
+from c3.libraries.hamiltonians import int_XX, x_drive
 from c3.parametermap import ParameterMap
+from c3.signal.gates import Instruction
 from c3.generator.generator import Generator
-from c3.generator.devices import Crosstalk
+from c3.generator.devices import (
+    AWG,
+    Crosstalk,
+    DigitalToAnalog,
+    LO,
+    Mixer,
+    VoltsToHertz,
+)
 from c3.libraries.constants import Id, X, Y, Z
 from c3.c3objs import Quantity
+from c3.optimizers.optimalcontrol import OptimalControl
+from c3.libraries.fidelities import unitary_infid_set
+from c3.libraries.algorithms import algorithms
 from c3.qiskit.c3_gates import RX90pGate, CR90Gate
 import pytest
 
@@ -27,7 +47,7 @@ def get_exp_problem() -> Iterator[Tuple[np.ndarray, np.ndarray]]:
     a = np.random.rand(1)
     b = np.random.rand(1)
     c = np.random.rand(1)
-    norm = np.sqrt(a ** 2 + b ** 2 + c ** 2)
+    norm = np.sqrt(a**2 + b**2 + c**2)
     # Normalized random coefficients
     a = a / norm
     b = b / norm
@@ -235,3 +255,272 @@ def get_test_dimensions() -> list:
     """Functions in qt_utils that allow arbitrary numbers of dimensions will be tested for all dimensions in this
     list."""
     return [3, 5, 10, 50]
+
+
+@pytest.fixture()
+def get_two_qubit_chip() -> Experiment:
+    """Setup a two qubit example with pre-optimized gates."""
+    qubit_lvls = 2
+    freq_q1 = 5e9
+    q1 = Qubit(
+        name="Q1",
+        desc="Qubit 1",
+        freq=Quantity(value=freq_q1, min_val=4.995e9, max_val=5.005e9, unit="Hz 2pi"),
+        hilbert_dim=qubit_lvls,
+    )
+
+    freq_q2 = 5.6e9
+    q2 = Qubit(
+        name="Q2",
+        desc="Qubit 2",
+        freq=Quantity(value=freq_q2, min_val=5.595e9, max_val=5.605e9, unit="Hz 2pi"),
+        hilbert_dim=qubit_lvls,
+    )
+
+    coupling_strength = 20e6
+    q1q2 = Coupling(
+        name="Q1-Q2",
+        desc="coupling",
+        comment="Coupling qubit 1 to qubit 2",
+        connected=["Q1", "Q2"],
+        strength=Quantity(
+            value=coupling_strength, min_val=-1 * 1e3, max_val=200e6, unit="Hz 2pi"
+        ),
+        hamiltonian_func=int_XX,
+    )
+
+    drive = Drive(
+        name="d1",
+        desc="Drive 1",
+        comment="Drive line 1 on qubit 1",
+        connected=["Q1"],
+        hamiltonian_func=x_drive,
+    )
+    drive2 = Drive(
+        name="d2",
+        desc="Drive 2",
+        comment="Drive line 2 on qubit 2",
+        connected=["Q2"],
+        hamiltonian_func=x_drive,
+    )
+
+    model = Model(
+        [q1, q2],  # Individual, self-contained components
+        [drive, drive2, q1q2],  # Interactions between components
+    )
+
+    model.set_lindbladian(False)
+    model.set_dressed(True)
+
+    sim_res = 100e9  # Resolution for numerical simulation
+    awg_res = 2e9  # Realistic, limited resolution of an AWG
+    v2hz = 1e9
+
+    generator = Generator(
+        devices={
+            "LO": LO(name="lo", resolution=sim_res, outputs=1),
+            "AWG": AWG(name="awg", resolution=awg_res, outputs=1),
+            "DigitalToAnalog": DigitalToAnalog(
+                name="dac", resolution=sim_res, inputs=1, outputs=1
+            ),
+            "Mixer": Mixer(name="mixer", inputs=2, outputs=1),
+            "VoltsToHertz": VoltsToHertz(
+                name="v_to_hz",
+                V_to_Hz=Quantity(
+                    value=v2hz, min_val=0.9e9, max_val=1.1e9, unit="Hz 2pi/V"
+                ),
+                inputs=1,
+                outputs=1,
+            ),
+        },
+        chains={
+            "d1": {
+                "LO": [],
+                "AWG": [],
+                "DigitalToAnalog": ["AWG"],
+                "Mixer": ["LO", "DigitalToAnalog"],
+                "VoltsToHertz": ["Mixer"],
+            },
+            "d2": {
+                "LO": [],
+                "AWG": [],
+                "DigitalToAnalog": ["AWG"],
+                "Mixer": ["LO", "DigitalToAnalog"],
+                "VoltsToHertz": ["Mixer"],
+            },
+        },
+    )
+
+    t_final = 7e-9  # Time for single qubit gates
+    amp = 359e-3  # prev optimized
+    sideband = 50e6
+    shift = coupling_strength**2 / (freq_q2 - freq_q1)
+    gauss_params_single = {
+        "amp": Quantity(value=amp, min_val=0.1, max_val=0.6, unit="V"),
+        "t_final": Quantity(
+            value=t_final, min_val=0.5 * t_final, max_val=1.5 * t_final, unit="s"
+        ),
+        "sigma": Quantity(
+            value=t_final / 4, min_val=t_final / 8, max_val=t_final / 2, unit="s"
+        ),
+        "xy_angle": Quantity(
+            value=0.0, min_val=-0.5 * np.pi, max_val=2.5 * np.pi, unit="rad"
+        ),
+        "freq_offset": Quantity(
+            value=-sideband - shift, min_val=-56 * 1e6, max_val=-48 * 1e6, unit="Hz 2pi"
+        ),
+    }
+
+    gauss_env_single = Envelope(
+        name="gauss",
+        desc="Gaussian comp for single-qubit gates",
+        params=gauss_params_single,
+        shape=gaussian_nonorm,
+    )
+
+    nodrive_env = Envelope(
+        name="no_drive",
+        params={
+            "t_final": Quantity(
+                value=t_final, min_val=0.5 * t_final, max_val=1.5 * t_final, unit="s"
+            )
+        },
+        shape=no_drive,
+    )
+
+    lo_freq_q1 = 5e9 + sideband
+    carrier_parameters = {
+        "freq": Quantity(value=lo_freq_q1, min_val=4.5e9, max_val=6e9, unit="Hz 2pi"),
+        "framechange": Quantity(
+            value=0.0, min_val=-np.pi, max_val=3 * np.pi, unit="rad"
+        ),
+    }
+
+    carr = Carrier(
+        name="carrier",
+        desc="Frequency of the local oscillator",
+        params=carrier_parameters,
+    )
+
+    lo_freq_q2 = 5.6e9 + sideband
+    carr_2 = copy.deepcopy(carr)
+    carr_2.params["freq"].set_value(lo_freq_q2)
+
+    rx90p_q1 = Instruction(
+        name="rx90p",
+        targets=[0],
+        t_start=0.0,
+        t_end=t_final,
+        channels=["d1", "d2"],
+        params={"use_t_before": True},
+    )
+    rx90p_q2 = Instruction(
+        name="rx90p",
+        targets=[1],
+        t_start=0.0,
+        t_end=t_final,
+        channels=["d1", "d2"],
+        params={"use_t_before": True},
+    )
+    QId_q1 = Instruction(
+        name="id",
+        targets=[0],
+        t_start=0.0,
+        t_end=t_final,
+        channels=["d1", "d2"],
+        params={"use_t_before": True},
+    )
+    QId_q2 = Instruction(
+        name="id",
+        targets=[1],
+        t_start=0.0,
+        t_end=t_final,
+        channels=["d1", "d2"],
+        params={"use_t_before": True},
+    )
+
+    rx90p_q1.add_component(gauss_env_single, "d1")
+    rx90p_q1.add_component(carr, "d1")
+    rx90p_q1.add_component(nodrive_env, "d2")
+    rx90p_q1.add_component(copy.deepcopy(carr_2), "d2")
+    rx90p_q1.comps["d2"]["carrier"].params["framechange"].set_value(
+        (-sideband * t_final) * 2 * np.pi % (2 * np.pi)
+    )
+
+    rx90p_q2.add_component(copy.deepcopy(gauss_env_single), "d2")
+    rx90p_q2.add_component(carr_2, "d2")
+    rx90p_q2.add_component(nodrive_env, "d1")
+    rx90p_q2.add_component(copy.deepcopy(carr), "d1")
+    rx90p_q2.comps["d1"]["carrier"].params["framechange"].set_value(
+        (-sideband * t_final) * 2 * np.pi % (2 * np.pi)
+    )
+
+    QId_q1.add_component(nodrive_env, "d1")
+    QId_q1.add_component(copy.deepcopy(carr), "d1")
+    QId_q1.add_component(nodrive_env, "d2")
+    QId_q1.add_component(copy.deepcopy(carr_2), "d2")
+    QId_q2.add_component(copy.deepcopy(nodrive_env), "d2")
+    QId_q2.add_component(copy.deepcopy(carr_2), "d2")
+    QId_q2.add_component(nodrive_env, "d1")
+    QId_q2.add_component(copy.deepcopy(carr), "d1")
+
+    Y90p_q1 = copy.deepcopy(rx90p_q1)
+    Y90p_q1.name = "ry90p"
+    X90m_q1 = copy.deepcopy(rx90p_q1)
+    X90m_q1.name = "rx90m"
+    Y90m_q1 = copy.deepcopy(rx90p_q1)
+    Y90m_q1.name = "ry90m"
+    Y90p_q1.comps["d1"]["gauss"].params["xy_angle"].set_value(0.5 * np.pi)
+    X90m_q1.comps["d1"]["gauss"].params["xy_angle"].set_value(np.pi)
+    Y90m_q1.comps["d1"]["gauss"].params["xy_angle"].set_value(1.5 * np.pi)
+    single_q_gates = [QId_q1, rx90p_q1, Y90p_q1, X90m_q1, Y90m_q1]
+
+    Y90p_q2 = copy.deepcopy(rx90p_q2)
+    Y90p_q2.name = "ry90p"
+    X90m_q2 = copy.deepcopy(rx90p_q2)
+    X90m_q2.name = "rx90m"
+    Y90m_q2 = copy.deepcopy(rx90p_q2)
+    Y90m_q2.name = "ry90m"
+    Y90p_q2.comps["d2"]["gauss"].params["xy_angle"].set_value(0.5 * np.pi)
+    X90m_q2.comps["d2"]["gauss"].params["xy_angle"].set_value(np.pi)
+    Y90m_q2.comps["d2"]["gauss"].params["xy_angle"].set_value(1.5 * np.pi)
+    single_q_gates.extend([QId_q2, rx90p_q2, Y90p_q2, X90m_q2, Y90m_q2])
+
+    pmap = ParameterMap(single_q_gates, generator, model)
+
+    pmap.set_opt_map(
+        [
+            [["rx90p[0]", "d1", "gauss", "amp"]],
+            [["rx90p[0]", "d1", "gauss", "freq_offset"]],
+            [["rx90p[0]", "d1", "gauss", "xy_angle"]],
+        ]
+    )
+    return Experiment(pmap)
+
+
+@pytest.fixture(
+    params=[
+        "single_eval",
+        "tf_sgd",
+        "lbfgs",
+        "lbfgs_grad_free",
+        "cmaes",
+        "cma_pre_lbfgs",
+    ]
+)
+def get_OC_optimizer(request, get_two_qubit_chip) -> OptimalControl:
+    """Create a general optimizer object with each algorithm with a decorator in the lib."""
+    exp = get_two_qubit_chip
+    exp.set_opt_gates(["rx90p[0]"])
+    logdir = os.path.join(tempfile.TemporaryDirectory().name, "c3logs")
+    opt = OptimalControl(
+        dir_path=logdir,
+        fid_func=unitary_infid_set,
+        pmap=exp.pmap,
+        fid_subspace=["Q1", "Q2"],
+        algorithm=algorithms[request.param],
+        options={"maxiters": 2} if request.param == "tf_sgd" else {"maxiter": 2},
+        run_name=f"better_X90_{request.param}",
+    )
+    opt.set_exp(exp)
+    return opt