Pass tests

.github/workflows/python-test.yml

@@ -0,0 +1,33 @@
+name: Python Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: [3.8, 3.9]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+
+    - name: Install the package
+      run: |
+        pip install .
+
+    - name: Run tests
+      run: |
+        pytest tests/relaqs -v

analysis/load_env_data.py

@@ -3,7 +3,7 @@
 """
 
 from relaqs import RESULTS_DIR
-from relaqs.api import load_pickled_env_data
+from relaqs.api.utils import load_pickled_env_data
 
 data_path = RESULTS_DIR + '2024-01-24_11-37-15_X/env_data.pkl'
 

requirements.txt

@@ -0,0 +1,4 @@
+ray[rllib]==2.4.0
+ray[tune]
+qutip
+torch

scripts/best_fidelities.txt

@@ -0,0 +1 @@
+(0.01754923417485625, 0.9963428890697784)

scripts/deterministic_agent.py

@@ -52,6 +52,4 @@
         print(f"Episode done: Total reward = {episode_reward}")
         obs, info = env.reset()
         num_episodes += 1
-        episode_reward = 0.0
-
-
+        episode_reward = 0.0

setup.cfg

@@ -17,6 +17,9 @@ install_requires =
 
 [options.packages.find]
 where = src
+
+[options.package_data]
+* = *.json
 
 [bdist_wheel]
 universal = 1

src/relaqs/api/__init__.py

@@ -1,4 +1,4 @@
 from .training import TrainRLLib
 from .callbacks import GateSynthesisCallbacks
 from .gates import Gate
-from .utils import gate_fidelity, dm_fidelity, load_pickled_env_data
+

src/relaqs/api/utils.py

@@ -1,16 +1,20 @@
-import ray
 import numpy as np
 from numpy.linalg import eigvalsh
 import pandas as pd
 from scipy.linalg import sqrtm
 from ray.rllib.algorithms.algorithm import Algorithm
 from ray.rllib.algorithms.ddpg import DDPGConfig
 from relaqs import RESULTS_DIR
+import ast
+from ray.tune.registry import register_env
+from relaqs.environments.single_qubit_env import SingleQubitEnv
+from relaqs.environments.noisy_single_qubit_env import NoisySingleQubitEnv
 from relaqs.quantum_noise_data.get_data import (get_month_of_all_qubit_data, get_single_qubit_detuning)
 from relaqs.api.callbacks import GateSynthesisCallbacks
 from relaqs import QUANTUM_NOISE_DATA_DIR
 from qutip.operators import *
 
+
 def load_pickled_env_data(data_path):
     df = pd.read_pickle(data_path)
     return df
@@ -76,63 +80,151 @@ def load_model(path):
     return loaded_model
 
 def get_best_episode_information(filename):
-    df = pd.read_csv(filename, names=['Fidelity', 'Reward', 'Actions', 'Flattened U', 'Episode Id'], header=0)
-    fidelity = df.iloc[:, 0]
+    data = load_pickled_env_data(filename)
+    fidelity = data["Fidelity"]
     max_fidelity_idx = fidelity.argmax()
-    fidelity = df.iloc[max_fidelity_idx, 0]
-    episode = df.iloc[max_fidelity_idx, 4]
-    best_episodes = df[df["Episode Id"] == episode]
+    fidelity = data.iloc[max_fidelity_idx, 0]
+    episode = data.iloc[max_fidelity_idx, 4]
+    best_episodes = data[data["Episode Id"] == episode]
     return best_episodes
 
+def noisy_env_creator(config):
+    return NoisySingleQubitEnv(config)
+
+def noiseless_env_creator(config):
+    return SingleQubitEnv(config)
+
 def run(env_class, gate, n_training_iterations=1, noise_file=""):
     """Args
        gate (Gate type):
+       environmment(gym.env)
        n_training_iterations (int)
        noise_file (str):
     Returns
       alg (rllib.algorithms.algorithm)
 
     """
-    ray.init()
+
     env_config = env_class.get_default_env_config()
     env_config["U_target"] = gate.get_matrix()
 
-    # ---------------------> Get quantum noise data <-------------------------
+
+# ---------------------> Get quantum noise data <-------------------------
     t1_list, t2_list, detuning_list = sample_noise_parameters(noise_file)
 
     env_config["relaxation_rates_list"] = [np.reciprocal(t1_list).tolist(), np.reciprocal(t2_list).tolist()] # using real T1 data
     env_config["delta"] = detuning_list
     env_config["relaxation_ops"] = [sigmam(),sigmaz()]
     env_config["observation_space_size"] = 2*16 + 1 + 2 + 1 # 2*16 = (complex number)*(density matrix elements = 4)^2, + 1 for fidelity + 2 for relaxation rate + 1 for detuning
-    env_config["verbose"] = True
-
     # ---------------------> Configure algorithm and Environment <-------------------------
     alg_config = DDPGConfig()
     alg_config.framework("torch")
     alg_config.environment(env_class, env_config=env_config)
     alg_config.rollouts(batch_mode="complete_episodes")
     alg_config.callbacks(GateSynthesisCallbacks)
     alg_config.train_batch_size = env_class.get_default_env_config()["steps_per_Haar"]
+    alg_config.actor_lr = 4e-5
+    alg_config.critic_lr = 5e-4
+
+    alg_config.actor_hidden_activation = "relu"
+    alg_config.critic_hidden_activation = "relu"
+    alg_config.num_steps_sampled_before_learning_starts = 1000
+    alg_config.actor_hiddens = [30,30,30, 30]
+    alg_config.exploration_config["scale_timesteps"] = 10000
+
+    alg = alg_config.build()
+    list_of_results = []
+    for _ in range(n_training_iterations):
+        result = alg.train()
+        list_of_results.append(result['hist_stats'])
+    return alg, list_of_results
+
+def run_noisless_one_qubit_experiment(gate,n_training_iterations=1):
+    """Args
+       gate (Gate type):
+       environmment(gym.env)
+       n_training_iterations (int)
+       noise_file (str):
+    Returns
+      alg (rllib.algorithms.algorithm)
+
+    """
+    register_env("my_env", noiseless_env_creator)
+    env_config =  SingleQubitEnv.get_default_env_config()
+    env_config["U_target"] = gate.get_matrix()
+    # env_config["observation_space_size"] = 2*16 + 1  # 2*16 = (complex number)*(density matrix elements = 4)^2, + 1 for fidelity 
+    env_config["verbose"] = True
+
+ # ---------------------> Configure algorithm and Environment <-------------------------
+    alg_config = DDPGConfig()
+    alg_config.framework("torch")
+    alg_config.environment("my_env", env_config=env_config)
+    alg_config.rollouts(batch_mode="complete_episodes")
+    alg_config.callbacks(GateSynthesisCallbacks)
+    alg_config.train_batch_size = SingleQubitEnv.get_default_env_config()["steps_per_Haar"]
 
-    ### working 1-3 sets
     alg_config.actor_lr = 4e-5
     alg_config.critic_lr = 5e-4
 
     alg_config.actor_hidden_activation = "relu"
     alg_config.critic_hidden_activation = "relu"
     alg_config.num_steps_sampled_before_learning_starts = 1000
-    alg_config.actor_hiddens = [30,30,30]
+    alg_config.actor_hiddens = [30,30,30, 30]
     alg_config.exploration_config["scale_timesteps"] = 10000
 
     alg = alg_config.build()
     list_of_results = []
     for _ in range(n_training_iterations):
         result = alg.train()
         list_of_results.append(result['hist_stats'])
+    return alg, list_of_results
 
-    ray.shutdown()
 
-    return alg
+def run_noisy_one_qubit_experiment(gate, n_training_iterations=1, noise_file="      "):
+    """Args
+       gate (Gate type):
+       environmment(gym.env)
+       n_training_iterations (int)
+       noise_file (str):
+    Returns
+      alg (rllib.algorithms.algorithm)
+
+    """
+    register_env("my_env", noisy_env_creator)
+    env_config = NoisySingleQubitEnv.get_default_env_config()
+    env_config["U_target"] = gate.get_matrix()
+    # ---------------------> Get quantum noise data <-------------------------
+    t1_list, t2_list, detuning_list = sample_noise_parameters(noise_file)
+
+    env_config["relaxation_rates_list"] = [np.reciprocal(t1_list).tolist(), np.reciprocal(t2_list).tolist()] # using real T1 data
+    env_config["delta"] = detuning_list
+    env_config["relaxation_ops"] = [sigmam(),sigmaz()]
+    env_config["observation_space_size"] = 2*16 + 1 + 2 + 1 # 2*16 = (complex number)*(density matrix elements = 4)^2, + 1 for fidelity + 2 for relaxation rate + 1 for detuning
+
+   # ---------------------> Configure algorithm and Environment <-------------------------
+    alg_config = DDPGConfig()
+    alg_config.framework("torch")
+    alg_config.environment(NoisySingleQubitEnv, env_config=env_config)
+    alg_config.rollouts(batch_mode="complete_episodes")
+    alg_config.callbacks(GateSynthesisCallbacks)
+    alg_config.train_batch_size = NoisySingleQubitEnv.get_default_env_config()["steps_per_Haar"]
+
+    alg_config.actor_lr = 4e-5
+    alg_config.critic_lr = 5e-4
+
+    alg_config.actor_hidden_activation = "relu"
+    alg_config.critic_hidden_activation = "relu"
+    alg_config.num_steps_sampled_before_learning_starts = 1000
+    alg_config.actor_hiddens = [30,30,30, 30]
+    alg_config.exploration_config["scale_timesteps"] = 10000
+
+    alg = alg_config.build()
+    list_of_results = []
+    for _ in range(n_training_iterations):
+        result = alg.train()
+        list_of_results.append(result['hist_stats'])
+    return alg, list_of_results
+
 
 def return_env_from_alg(alg):
     env = alg.workers.local_worker().env