QuLab 2.6.2__tar.gz → 2.7.1__tar.gz

{qulab-2.6.2 → qulab-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: QuLab
-Version: 2.6.2
+Version: 2.7.1
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

{qulab-2.6.2 → qulab-2.7.1}/QuLab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: QuLab
-Version: 2.6.2
+Version: 2.7.1
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

{qulab-2.6.2 → qulab-2.7.1}/qulab/executor/cli.py

@@ -10,9 +10,9 @@ from loguru import logger
 from ..cli.config import get_config_value, log_options
 from .load import (WorkflowType, find_unreferenced_workflows, get_entries,
                    load_workflow, make_graph)
+from .schedule import CalibrationFailedError
 from .schedule import maintain as maintain_workflow
 from .schedule import run as run_workflow
-from .schedule import CalibrationFailedError
 from .transform import set_config_api
 from .utils import workflow_template
 
@@ -137,10 +137,10 @@ def get(key, api):
               is_flag=True,
               help='Do not run dependents.')
 @click.option('--retry', '-r', default=1, type=int, help='Retry times.')
-@click.option('--update', '-u', is_flag=True)
+@click.option('--freeze', is_flag=True, help='Freeze the config table.')
 @log_options
 @command_option('run')
-def run(workflow, code, data, api, plot, no_dependents, retry, update):
+def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
     """
     Run a workflow.
     """
@@ -149,7 +149,7 @@ def run(workflow, code, data, api, plot, no_dependents, retry, update):
         f'{" --plot" if plot else ""}'
         f'{" --no-dependents" if no_dependents else ""}'
         f' --retry {retry}'
-        f'{" --update " if update else ""}')
+        f'{" --freeze " if freeze else ""}')
     if api is not None:
         api = importlib.import_module(api)
         set_config_api(api.query_config, api.update_config, api.export_config)
@@ -173,9 +173,9 @@ def run(workflow, code, data, api, plot, no_dependents, retry, update):
                                      code,
                                      data,
                                      plot=plot,
-                                     update=update)
+                                     freeze=freeze)
                 else:
-                    run_workflow(wf, code, data, plot=plot, update=update)
+                    run_workflow(wf, code, data, plot=plot, freeze=freeze)
             else:
                 if hasattr(wf, 'entries'):
                     for entry in get_entries(wf, code):
@@ -184,14 +184,14 @@ def run(workflow, code, data, api, plot, no_dependents, retry, update):
                                           data,
                                           run=True,
                                           plot=plot,
-                                          update=update)
+                                          freeze=freeze)
                 else:
                     maintain_workflow(wf,
                                       code,
                                       data,
                                       run=True,
                                       plot=plot,
-                                      update=update)
+                                      freeze=freeze)
             break
         except CalibrationFailedError as e:
             if i == retry - 1:
@@ -232,9 +232,19 @@ def maintain(workflow, code, data, api, retry, plot):
         try:
             if hasattr(wf, 'entries'):
                 for entry in get_entries(wf, code):
-                    maintain_workflow(entry, code, data, run=False, plot=plot)
+                    maintain_workflow(entry,
+                                      code,
+                                      data,
+                                      run=False,
+                                      plot=plot,
+                                      freeze=False)
             else:
-                maintain_workflow(wf, code, data, run=False, plot=plot)
+                maintain_workflow(wf,
+                                  code,
+                                  data,
+                                  run=False,
+                                  plot=plot,
+                                  freeze=False)
         except CalibrationFailedError as e:
             if i == retry - 1:
                 raise e

{qulab-2.6.2 → qulab-2.7.1}/qulab/executor/load.py

@@ -24,6 +24,7 @@ class SetConfigWorkflow():
 
     def __init__(self, key):
         self.key = key
+        self.__workflow_id__ = f"cfg:{self.key}"
 
     def depends(self):
         return []
@@ -31,7 +32,7 @@ class SetConfigWorkflow():
     def check_state(self, history: Result) -> bool:
         from . import transform
         try:
-            return self._equal(history.params[self.key],
+            return self._equal(history.parameters[self.key],
                                transform.query_config(self.key))
         except:
             return False
@@ -50,18 +51,22 @@ class SetConfigWorkflow():
         return result
 
     def check(self):
-        from .transform import query_config
-        return query_config(self.key)
+        return self.calibrate()
 
-    def check_analyze(self, result: Result, history: Result):
-        result.state = 'Outdated'
-        result.parameters = {self.key: result.data}
+    def check_analyze(self, result: Result, history: Result | None):
+        if self.check_state(history):
+            result.state = 'OK'
+            result.parameters = {self.key: history.data}
+        else:
+            result.state = 'Outdated'
         return result
 
     @staticmethod
     def _equal(a, b):
         import numpy as np
 
+        if a is b:
+            return True
         try:
             return a == b
         except:

{qulab-2.6.2 → qulab-2.7.1}/qulab/executor/schedule.py

@@ -7,9 +7,9 @@ from pathlib import Path
 from loguru import logger
 
 from .load import WorkflowType, get_dependents
-from .storage import (Result, find_result, renew_result, revoke_result,
-                      save_result)
-from .transform import current_config, update_parameters
+from .storage import (Result, find_result, get_heads, renew_result,
+                      revoke_result, save_result)
+from .transform import current_config, obey_the_oracle, update_parameters
 
 
 class CalibrationFailedError(Exception):
@@ -100,6 +100,24 @@ def call_analyzer(node,
     else:
         result = node.analyze(result, history=history)
         veryfy_analyzed_result(result, node.__workflow_id__, "analyze")
+        if hasattr(node, 'oracle') and callable(node.oracle):
+            logger.debug(
+                f'"{node.__workflow_id__}" has oracle method, calling ...')
+            try:
+                result = node.oracle(result,
+                                     history=history,
+                                     system_state=get_heads(result.base_path))
+            except Exception as e:
+                logger.exception(e)
+                result.oracle = {}
+            if not isinstance(result, Result):
+                raise TypeError(
+                    f'"{node.__workflow_id__}" : function "oracle" must return a Result object'
+                )
+            if not is_pickleable(result.oracle):
+                raise TypeError(
+                    f'"{node.__workflow_id__}" : function "oracle" return not pickleable data'
+                )
         result.fully_calibrated = True
         if plot:
             call_plot(node, result)
@@ -276,6 +294,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
 
     result = calibrate(workflow, code_path, state_path, plot, session_id)
     if result.bad_data or not result.in_spec:
+        obey_the_oracle(result, state_path)
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
@@ -290,7 +309,7 @@ def maintain(workflow: WorkflowType,
              session_id: str | None = None,
              run: bool = False,
              plot: bool = False,
-             update: bool = True):
+             freeze: bool = False):
     if session_id is None:
         session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}"'
@@ -300,7 +319,13 @@ def maintain(workflow: WorkflowType,
         logger.debug(
             f'maintain "{n.__workflow_id__}" because it is depended by "{workflow.__workflow_id__}"'
         )
-        maintain(n, code_path, state_path, session_id, run=False, plot=plot)
+        maintain(n,
+                 code_path,
+                 state_path,
+                 session_id,
+                 run=False,
+                 plot=plot,
+                 freeze=freeze)
     else:
         logger.debug(
             f'"{workflow.__workflow_id__}": All dependents maintained')
@@ -331,10 +356,12 @@ def maintain(workflow: WorkflowType,
     logger.debug(f'recalibrate "{workflow.__workflow_id__}"')
     result = calibrate(workflow, code_path, state_path, plot, session_id)
     if result.bad_data or not result.in_spec:
+        if not freeze:
+            obey_the_oracle(result, state_path)
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
-    if update:
+    if not freeze:
         update_parameters(result, state_path)
     return
 
@@ -344,7 +371,7 @@ def run(workflow: WorkflowType,
         code_path: str | Path,
         state_path: str | Path,
         plot: bool = False,
-        update: bool = True):
+        freeze: bool = False):
     session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}" without dependences.')
     result = calibrate(workflow,
@@ -353,9 +380,11 @@ def run(workflow: WorkflowType,
                        plot,
                        session_id=session_id)
     if result.bad_data or not result.in_spec:
+        if not freeze:
+            obey_the_oracle(result, state_path)
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
-    if update:
+    if not freeze:
         update_parameters(result, state_path)
     return

{qulab-2.6.2 → qulab-2.7.1}/qulab/executor/storage.py

@@ -12,6 +12,8 @@ from loguru import logger
 
 from ..cli.config import get_config_value
 
+__current_config_cache = None
+
 
 @dataclass
 class Result():
@@ -23,6 +25,7 @@ class Result():
     checked_time: datetime = field(default_factory=datetime.now)
     ttl: timedelta = timedelta(days=3650)
     parameters: dict = field(default_factory=dict)
+    oracle: dict = field(default_factory=dict)
     other_infomation: dict = field(default_factory=dict)
     data: Any = field(default_factory=tuple)
     index: int = -1
@@ -84,10 +87,56 @@ def random_path(base: Path) -> Path:
             return path
 
 
+def save_config_key_history(key: str, result: Result,
+                            base_path: str | Path) -> int:
+    global __current_config_cache
+    base_path = Path(base_path) / 'state'
+    base_path.mkdir(parents=True, exist_ok=True)
+
+    if __current_config_cache is None:
+        if (base_path / 'parameters.pkl').exists():
+            with open(base_path / 'parameters.pkl', 'rb') as f:
+                __current_config_cache = pickle.load(f)
+        else:
+            __current_config_cache = {}
+
+    __current_config_cache[key] = result.data
+
+    with open(base_path / 'parameters.pkl', 'wb') as f:
+        pickle.dump(__current_config_cache, f)
+    return 0
+
+
+def find_config_key_history(key: str, base_path: str | Path) -> Result | None:
+    global __current_config_cache
+    base_path = Path(base_path) / 'state'
+    if __current_config_cache is None:
+        if (base_path / 'parameters.pkl').exists():
+            with open(base_path / 'parameters.pkl', 'rb') as f:
+                __current_config_cache = pickle.load(f)
+        else:
+            __current_config_cache = {}
+
+    if key in __current_config_cache:
+        value = __current_config_cache.get(key, None)
+        result = Result(workflow=f'cfg:{key}',
+                        bad_data=False,
+                        in_spec=True,
+                        fully_calibrated=True,
+                        parameters={key: value},
+                        data=value)
+        result.bad_data = False
+        return result
+    return None
+
+
 def save_result(workflow: str,
                 result: Result,
                 base_path: str | Path,
                 overwrite: bool = False) -> int:
+    if workflow.startswith("cfg:"):
+        return save_config_key_history(workflow[4:], result, base_path)
+
     logger.debug(
         f'Saving result for "{workflow}", {result.in_spec=}, {result.bad_data=}, {result.fully_calibrated=}'
     )
@@ -131,6 +180,9 @@ def load_result(path: str | Path, base_path: str | Path) -> Result | None:
 def find_result(
     workflow: str, base_path: str | Path = get_config_value("data", Path)
 ) -> Result | None:
+    if workflow.startswith("cfg:"):
+        return find_config_key_history(workflow[4:], base_path)
+
     base_path = Path(base_path)
     path = get_head(workflow, base_path)
     if path is None:

{qulab-2.6.2 → qulab-2.7.1}/qulab/executor/transform.py

@@ -43,6 +43,13 @@ def _export_config() -> dict:
     return parameters
 
 
+def obey_the_oracle(result: Result, data_path):
+    global __current_config_id
+    update_config(result.oracle)
+    cfg = export_config()
+    __current_config_id = save_config(cfg, data_path)
+
+
 def update_parameters(result: Result, data_path):
     global __current_config_id
     update_config(result.parameters)

{qulab-2.6.2 → qulab-2.7.1}/qulab/executor/utils.py

@@ -133,6 +133,25 @@ def check_analyze(result: Result, history: Result | None = None) -> Result:
     result.state = random.choice(['Outdated', 'OK', 'Bad'])
 
     return result
+
+
+def oracle(result: Result,
+           history: Result | None = None,
+           system_state: dict[str:str] | None = None) -> Result:
+    \"\"\"
+    谕示：指凭直觉或经验判断，改动某些配置，以期望下次校准成功。
+    
+    当校准失败时，根据 analyze 的结果，尝试改变某些配置再重新校准整个系统。
+    比如通常我们在死活测不到 rabi 或能谱时，会换一个 idle bias 再试试。这
+    里我们凭直觉设的那个 bias 值，就是一个谕示，可以通过 oracle 来设定。
+
+    该函数代入的参数 result 是 analyze 函数的返回值。
+    \"\"\"
+
+    # result.oracle['Q0.bias'] = 0.1
+    # result.oracle['Q1.bias'] = -0.03
+
+    return result
 """
 
 

qulab-2.7.1/qulab/version.py

@@ -0,0 +1 @@
+__version__ = "2.7.1"

qulab-2.6.2/qulab/version.py

@@ -1 +0,0 @@
-__version__ = "2.6.2"