QML Architecture Updates (#145)

* Updated structural changes * Modified docstrings --------- Co-authored-by: Greshma Shaji <[email protected]>
QUARK-framework · Nov 7, 2024 · 21fa376 · 21fa376
1 parent 62a87b5
commit 21fa376
Show file tree

Hide file tree

Showing 26 changed files with 3,822 additions and 3,720 deletions.
diff --git a/.settings/module_db.json b/.settings/module_db.json
diff --git a/src/modules/applications/qml/Circuit.py b/src/modules/applications/qml/Circuit.py
@@ -0,0 +1,33 @@
+#  Copyright 2021 The QUARK Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from abc import ABC, abstractmethod
+from modules.Core import Core
+
+
+class Circuit(Core, ABC):
+    """
+    This module is abstract base class for the library-agnostic gate sequence, that define a quantum circuit.
+    """
+
+    @abstractmethod
+    def generate_gate_sequence(self, input_data: dict, config: any) -> dict:
+        """
+        Generates the library agnostic gate sequence, a well-defined definition of the quantum circuit.
+
+        :param input_data: Input data required to generate the gate sequence
+        :param config: Configuration for the gate sequence
+        :return: Generated gate sequence
+        """
+        pass
diff --git a/src/modules/applications/qml/DataHandler.py b/src/modules/applications/qml/DataHandler.py
@@ -0,0 +1,69 @@
+#  Copyright 2021 The QUARK Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from abc import ABC, abstractmethod
+
+import pandas as pd
+from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
+
+
+class DataHandler(ABC):
+    """
+    Abstract base class for DataHandler. This class defines the
+    necessary methods that both supervised and unsupervised QML applciations
+    must implement.
+    """
+
+    @abstractmethod
+    def data_load(self, gen_mod: dict, config: dict) -> tuple[any, float]:
+        """
+        Helps to ensure that the model can effectively learn the underlying
+        patterns and structure of the data, and produce high-quality outputs.
+
+        :param gen_mod: Dictionary with collected information of the previous modules
+        :param config: Config specifying the parameters of the data handler
+        :return: Mapped problem and the time it took to create the mapping
+        """
+        pass
+
+    @abstractmethod
+    def evaluate(self, solution: any) -> tuple[any, float]:
+        """
+        Computes the best loss values.
+
+        :param solution: Solution data
+        :return: Evaluation data and the time it took to create it
+        """
+        pass
+
+    @staticmethod
+    def tb_to_pd(logdir: str, rep: str) -> None:
+        """
+        Converts TensorBoard event files in the specified log directory
+        into a pandas DataFrame and saves it as a pickle file.
+
+        :param logdir: Path to the log directory containing TensorBoard event files
+        :param rep: Repetition counter
+        """
+        event_acc = EventAccumulator(logdir)
+        event_acc.Reload()
+        tags = event_acc.Tags()
+        data = []
+        tag_data = {}
+        for tag in tags['scalars']:
+            data = event_acc.Scalars(tag)
+            tag_values = [d.value for d in data]
+            tag_data[tag] = tag_values
+        data = pd.DataFrame(tag_data, index=[d.step for d in data])
+        data.to_pickle(f"{logdir}/data_{rep}.pkl")
diff --git a/src/modules/applications/qml/Model.py b/src/modules/applications/qml/Model.py
@@ -0,0 +1,59 @@
+#  Copyright 2021 The QUARK Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+
+from abc import ABC, abstractmethod
+
+
+class Model(ABC):
+    """
+    Abstract base class for any quantum model. This class defines the necessary methods
+    that models like 'LibraryGenerative' must implement.
+    """
+
+    @abstractmethod
+    def sequence_to_circuit(self, input_data: dict) -> dict:
+        """
+        Abstract method to convert a sequence into a quantum circuit.
+
+        :param input_data: Input data representing the gate sequence
+        :return: A dictionary representing the quantum circuit
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def get_execute_circuit(circuit: any, backend: any, config: str, config_dict: dict) -> tuple[any, any]:
+        """
+        This method combines the circuit implementation and the selected backend and returns a function that will be
+        called during training.
+
+        :param circuit: Implementation of the quantum circuit
+        :param backend: Configured qiskit backend
+        :param config: Name of a backend
+        :param config_dict: Dictionary including the number of shots
+        :return: Tuple that contains a method that executes the quantum circuit for a given set of parameters and the
+        transpiled circuit
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def select_backend(config: str, n_qubits: int) -> any:
+        """
+        This method configures the backend.
+
+        :param config: Name of a backend
+        :param n_qubits: Number of qubits
+        :return: Configured backend
+        """
+        pass
diff --git a/src/modules/applications/qml/Training.py b/src/modules/applications/qml/Training.py
@@ -0,0 +1,33 @@
+#  Copyright 2021 The QUARK Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from abc import ABC, abstractmethod
+
+
+class Training(ABC):
+    """
+    Abstract base class for training QML models.
+    """
+
+    @abstractmethod
+    def start_training(self, input_data: dict, config: any, **kwargs: dict) -> dict:
+        """
+        This function starts the training of QML model or deploys a pretrained model.
+
+        :param input_data: A representation of the quantum machine learning model that will be trained
+        :param config: Config specifying the parameters of the training (dict-like Config type defined in children)
+        :param kwargs: Optional additional settings
+        :return: Solution, the time it took to compute it and some optional additional information
+        """
+        pass
diff --git a/src/modules/circuits/CircuitCardinality.py → ...e_modeling/circuits/CircuitCardinality.py b/src/modules/circuits/CircuitCardinality.py → ...e_modeling/circuits/CircuitCardinality.py
@@ -14,14 +14,14 @@
 
 from typing import Union, TypedDict
 
-from modules.circuits.Circuit import Circuit
+from modules.applications.qml.generative_modeling.circuits.CircuitGenerative import CircuitGenerative
 from modules.applications.qml.generative_modeling.mappings.LibraryQiskit import LibraryQiskit
 from modules.applications.qml.generative_modeling.mappings.LibraryPennylane import LibraryPennylane
 from modules.applications.qml.generative_modeling.mappings.PresetQiskitNoisyBackend import PresetQiskitNoisyBackend
 from modules.applications.qml.generative_modeling.mappings.CustomQiskitNoisyBackend import CustomQiskitNoisyBackend
 
 
-class CircuitCardinality(Circuit):
+class CircuitCardinality(CircuitGenerative):
     """
     This class generates a library-agnostic gate sequence, i.e. a list containing information
     about the gates and the wires they act on.

diff --git a/src/modules/circuits/CircuitCopula.py → ...rative_modeling/circuits/CircuitCopula.py b/src/modules/circuits/CircuitCopula.py → ...rative_modeling/circuits/CircuitCopula.py
@@ -16,14 +16,14 @@
 from itertools import combinations
 from scipy.special import binom
 
-from modules.circuits.Circuit import Circuit
+from modules.applications.qml.generative_modeling.circuits.CircuitGenerative import CircuitGenerative
 from modules.applications.qml.generative_modeling.mappings.LibraryQiskit import LibraryQiskit
 from modules.applications.qml.generative_modeling.mappings.LibraryPennylane import LibraryPennylane
 from modules.applications.qml.generative_modeling.mappings.PresetQiskitNoisyBackend import PresetQiskitNoisyBackend
 from modules.applications.qml.generative_modeling.mappings.CustomQiskitNoisyBackend import CustomQiskitNoisyBackend
 
 
-class CircuitCopula(Circuit):
+class CircuitCopula(CircuitGenerative):
     """
     This class generates a library-agnostic gate sequence, i.e. a list containing information
     about the gates and the wires they act on. The marginal distributions generated by the copula

diff --git a/src/modules/circuits/Circuit.py → ...ve_modeling/circuits/CircuitGenerative.py b/src/modules/circuits/Circuit.py → ...ve_modeling/circuits/CircuitGenerative.py
@@ -12,12 +12,14 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from modules.Core import Core
 from utils import start_time_measurement, end_time_measurement
 
+from modules.applications.qml.Circuit import Circuit
 
-class Circuit(Core, ABC):
+
+class CircuitGenerative(Circuit, Core, ABC):
     """
     This module is abstract base class for the library-agnostic gate sequence, that define a quantum circuit.
     """
@@ -31,17 +33,6 @@ def __init__(self, name: str):
         super().__init__()
         self.architecture_name = name
 
-    @abstractmethod
-    def generate_gate_sequence(self, input_data: dict, config: any) -> dict:
-        """
-        Generates the library agnostic gate sequence, a well-defined definition of the quantum circuit.
-
-        :param input_data: Input data required to generate the gate sequence
-        :param config: Configuration for the gate sequence
-        :return: Generated gate sequence
-        """
-        pass
-
     def preprocess(self, input_data: dict, config: dict, **kwargs) -> tuple[dict, float]:
         """
         Library-agnostic implementation of the gate sequence, that will be mapped to backend such as Qiskit in the

diff --git a/src/modules/circuits/CircuitStandard.py → ...tive_modeling/circuits/CircuitStandard.py b/src/modules/circuits/CircuitStandard.py → ...tive_modeling/circuits/CircuitStandard.py
@@ -14,14 +14,14 @@
 
 from typing import Union, TypedDict
 
-from modules.circuits.Circuit import Circuit
+from modules.applications.qml.generative_modeling.circuits.CircuitGenerative import CircuitGenerative
 from modules.applications.qml.generative_modeling.mappings.LibraryQiskit import LibraryQiskit
 from modules.applications.qml.generative_modeling.mappings.LibraryPennylane import LibraryPennylane
 from modules.applications.qml.generative_modeling.mappings.PresetQiskitNoisyBackend import PresetQiskitNoisyBackend
 from modules.applications.qml.generative_modeling.mappings.CustomQiskitNoisyBackend import CustomQiskitNoisyBackend
 
 
-class CircuitStandard(Circuit):
+class CircuitStandard(CircuitGenerative):
     """
     This class generates a library-agnostic gate sequence, i.e. a list containing information
     about the gates and the wires they act on.

diff --git a/src/modules/circuits/__init__.py → .../generative_modeling/circuits/__init__.py b/src/modules/circuits/__init__.py → .../generative_modeling/circuits/__init__.py
diff --git a/src/modules/applications/qml/generative_modeling/data/data_handler/ContinuousData.py b/src/modules/applications/qml/generative_modeling/data/data_handler/ContinuousData.py
@@ -21,10 +21,10 @@
 from utils import start_time_measurement, end_time_measurement
 from modules.applications.qml.generative_modeling.transformations.MinMax import MinMax
 from modules.applications.qml.generative_modeling.transformations.PIT import PIT
-from modules.applications.qml.generative_modeling.data.data_handler.DataHandler import DataHandler
+from modules.applications.qml.generative_modeling.data.data_handler.DataHandlerGenerative import DataHandlerGenerative
 
 
-class ContinuousData(DataHandler):
+class ContinuousData(DataHandlerGenerative):
     """
     A data handler for continuous datasets. This class loads a dataset from a specified path and provides
     methods for data transformation and evaluation.

diff --git a/...modeling/data/data_handler/DataHandler.py → ...ata/data_handler/DataHandlerGenerative.py b/...modeling/data/data_handler/DataHandler.py → ...ata/data_handler/DataHandlerGenerative.py
@@ -14,18 +14,17 @@
 
 import pickle
 import os
-from abc import ABC, abstractmethod
+from abc import ABC
 from qiskit import qpy
 
 import numpy as np
-import pandas as pd
-from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
 
 from modules.Core import Core
+from modules.applications.qml.DataHandler import DataHandler
 from utils import start_time_measurement, end_time_measurement
 
 
-class DataHandler(Core, ABC):
+class DataHandlerGenerative(Core, DataHandler, ABC):
     """
     The task of the DataHandler module is to translate the application’s data
     and problem specification into preprocessed format.
@@ -103,7 +102,7 @@ def postprocess(self, input_data: dict, config: dict, **kwargs) -> tuple[dict, f
 
         # Save metrics per iteration
         if "inference" not in input_data.keys():
-            DataHandler.tb_to_pd(logdir=store_dir_iter, rep=str(kwargs['rep_count']))
+            self.tb_to_pd(logdir=store_dir_iter, rep=str(kwargs['rep_count']))
             self.metrics.add_metric_batch(
                 {"metrics_pandas": os.path.relpath(f"{store_dir_iter}/data.pkl", current_directory)}
             )
@@ -155,18 +154,6 @@ def postprocess(self, input_data: dict, config: dict, **kwargs) -> tuple[dict, f
 
         return input_data, end_time_measurement(start)
 
-    @abstractmethod
-    def data_load(self, gen_mod: dict, config: dict) -> tuple[any, float]:
-        """
-        Helps to ensure that the model can effectively learn the underlying
-        patterns and structure of the data, and produce high-quality outputs.
-
-        :param gen_mod: Dictionary with collected information of the previous modules
-        :param config: Config specifying the parameters of the data handler
-        :return: Mapped problem and the time it took to create the mapping
-        """
-        pass
-
     def generalization(self) -> tuple[dict, float]:
         """
         Computes generalization metrics.
@@ -177,34 +164,3 @@ def generalization(self) -> tuple[dict, float]:
         metrics = {}  # Replace with actual metric calculations
         time_taken = 0.0  # Replace with actual time calculation
         return metrics, time_taken
-
-    @abstractmethod
-    def evaluate(self, solution: any) -> tuple[any, float]:
-        """
-        Computes the best loss values.
-
-        :param solution: Solution data
-        :return: Evaluation data and the time it took to create it
-        """
-        return None, 0.0
-
-    @staticmethod
-    def tb_to_pd(logdir: str, rep: str) -> None:
-        """
-        Converts TensorBoard event files in the specified log directory
-        into a pandas DataFrame and saves it as a pickle file.
-
-        :param logdir: Path to the log directory containing TensorBoard event files
-        :param rep: Repetition counter
-        """
-        event_acc = EventAccumulator(logdir)
-        event_acc.Reload()
-        tags = event_acc.Tags()
-        data = []
-        tag_data = {}
-        for tag in tags['scalars']:
-            data = event_acc.Scalars(tag)
-            tag_values = [d.value for d in data]
-            tag_data[tag] = tag_values
-        data = pd.DataFrame(tag_data, index=[d.step for d in data])
-        data.to_pickle(f"{logdir}/data_{rep}.pkl")
diff --git a/src/modules/applications/qml/generative_modeling/data/data_handler/DiscreteData.py b/src/modules/applications/qml/generative_modeling/data/data_handler/DiscreteData.py
@@ -19,13 +19,13 @@
 
 import numpy as np
 
-from modules.circuits.CircuitCardinality import CircuitCardinality
-from modules.applications.qml.generative_modeling.data.data_handler.DataHandler import DataHandler
-from modules.applications.qml.generative_modeling.data.data_handler.MetricsGeneralization import MetricsGeneralization
+from modules.applications.qml.generative_modeling.circuits.CircuitCardinality import CircuitCardinality
+from modules.applications.qml.generative_modeling.data.data_handler.DataHandlerGenerative import DataHandlerGenerative
+from modules.applications.qml.generative_modeling.metrics.MetricsGeneralization import MetricsGeneralization
 from utils import start_time_measurement, end_time_measurement
 
 
-class DiscreteData(DataHandler):
+class DiscreteData(DataHandlerGenerative):
     """
     A data handler for discrete datasets with cardinality constraints.
     This class creates a dataset with a cardinality constraint and provides