From 4bf84119aef49f3b7206be8b0f9a797c2fcb4816 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Denise/Den=C4=8Da?= <95103224+denvitko@users.noreply.github.com> Date: Tue, 13 Jun 2023 11:00:10 +0200 Subject: [PATCH 001/106] added docstrings --- torchquantum/optimization.py | 64 ++++++++++++++++++++++++++++-------- 1 file changed, 51 insertions(+), 13 deletions(-) diff --git a/torchquantum/optimization.py b/torchquantum/optimization.py index 144ae4ca..49b1e856 100644 --- a/torchquantum/optimization.py +++ b/torchquantum/optimization.py @@ -8,6 +8,28 @@ def acquisition(x_scaled, hyper_param, model, min_Y): # x_scaled: 1 * dim + """Computes the acquisition value for a given input. + + Args: + x_scaled (numpy.ndarray): The scaled input vector of shape (1, dim). + hyper_param (list): The parameter for the acquisition function e.g., ['LCB','0.3'], ['EI'], ['PI']. + model: The surrogate model used for predictions. + min_Y (float): The minimum observed value. + + Returns: + float: The computed acquisition value. + + Raises: + ValueError: If the acquisition function is not implemented. + + Example: + >>> x = np.array([0.5, 0.3, 0.8]) + >>> hyper_param = ['LCB', 0.2] + >>> model = ... + >>> min_Y = 0.1 + >>> acquisition_value = acquisition(x, hyper_param, model, min_Y) + """ + x_scaled = x_scaled.reshape(1, -1) if "LCB" in hyper_param[0]: mean, std = model.predict(x_scaled, return_std=True) @@ -39,19 +61,35 @@ def bayes_opt( verbose=True, file_suffix="", ): - """ - - :param func: [functional handle], represents the objective function. objective = func(design) - :param dim_design: [int], the dimension of the design variable - :param N_sim: [int], The total number of allowable simulations - :param N_initial: [int], The number of simulations used to set up the initial dataset - :param w_bound: [(dim_design, 2) np.array], the i-th row contains the lower bound and upper bound for the i-th variable - :param hyper_param: the parameter for the acquisition function e.g., ['LCB','0.3'], ['EI'], ['PI'] - :param verbose: [Bool], if it is true, print detailed information in each iteration of Bayesian optimization - :param file_suffix: [string], file suffix used in storing optimization information - :return: - cur_best_w: [(dim_design,) np.array], the best design variable - cur_best_y: [float], the minimum objective value + """Performs Bayesian optimization to minimize the objective function. + + Args: + func (function): The objective function to minimize. The function should take a design variable as input and return a scalar objective value. + objective = func(design) + dim_design (int): The dimension of the design variable. + N_sim (int): The total number of allowable simulations. + N_initial (int): The number of simulations used to set up the initial dataset. + w_bound ((dim_design, 2) np.array): An array of shape (dim_design, 2) where each row contains the lower and upper bounds for the corresponding variable. + hyper_param (list): The parameters for the acquisition function, e.g., ['LCB', '0.3'], ['EI'], ['PI']. + store (bool): If True, store the optimization information. + Defaults to False. + verbose (bool): If True, print detailed information in each iteration of Bayesian optimization. + Defaults to True. + file_suffix (str): File suffix used in storing optimization information. + + Returns: + cur_best_w ((dim_design,) np.array): The best design variable + cur_best_y (float): The minimum objective value + + Example: + >>> def func(x): + >>> return x**2 + >>> dim_design = 1 + >>> N_sim = 10 + >>> N_initial = 2 + >>> w_bound = np.array([[0, 1]]) + >>> hyper_param = ['LCB', 0.3] + >>> bayes_opt(func, dim_design, N_sim, N_initial, w_bound, hyper_param) """ # initialization: set up the training dataset X, Y. From 3610ea5562b8d5860bed07878c9681613ff2ed43 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Denise/Den=C4=8Da?= <95103224+denvitko@users.noreply.github.com> Date: Tue, 13 Jun 2023 15:27:06 +0200 Subject: [PATCH 002/106] added docstrings --- torchquantum/datasets/vowel.py | 313 +++++++++++++++++++++++++++++++++ 1 file changed, 313 insertions(+) diff --git a/torchquantum/datasets/vowel.py b/torchquantum/datasets/vowel.py index 56908211..36ab58a8 100644 --- a/torchquantum/datasets/vowel.py +++ b/torchquantum/datasets/vowel.py @@ -22,6 +22,16 @@ class VowelRecognition(VisionDataset): + """Vowel Recognition dataset. + + Attributes: + classes (list): List of classes in the dataset. + class_to_idx (dict): Mapping from class names to class indices. + idx_to_class (dict): Mapping from class indices to class names. + samples (list): List of (sample path, class index) tuples. + n_features (int): Number of features to consider from the dataset. + """ + url = ( "http://archive.ics.uci.edu/ml/machine-learning-databases" "/undocumented/connectionist-bench/vowel/vowel-context.data" @@ -39,6 +49,30 @@ def __init__( train_ratio: float = 0.7, download: bool = False, ) -> None: + """Initialize the Vowel Recognition dataset. + + Args: + root (str): Root directory of the dataset. + train (bool, optional): Determines whether to load the training set or the test set. + Defaults to True (training set). + transform (callable, optional): A function/transform that takes in the raw data and returns a transformed version. + Defaults to None. + target_transform (callable, optional): A function/transform that takes in the target and returns a transformed version. + Defaults to None. + n_features (int, optional): Number of features to consider from the dataset. + Defaults to 10. + train_ratio (float, optional): Ratio of training samples to use if the dataset is split into training and test sets. + Defaults to 0.7. + download (bool, optional): If True, downloads the dataset from the internet and places it in the root directory. + Defaults to False. + + Raises: + RuntimeError: If the dataset is not found or corrupted and download is not enabled. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + """ + root = os.path.join(os.path.expanduser(root), self.folder) if transform is None: transform = transforms.Compose([transforms.ToTensor()]) @@ -69,6 +103,18 @@ def __init__( self.data, self.targets = self.load(train=train) def process_raw_data(self) -> None: + """Process the raw data of the dataset. + + This method is called during initialization to load and process the raw data into a suitable format for the dataset. + + Returns: + None. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> dataset.process_raw_data() + """ + processed_dir = os.path.join(self.root, "processed") processed_training_file = os.path.join(processed_dir, "training.pt") processed_test_file = os.path.join(processed_dir, "test.pt") @@ -90,6 +136,20 @@ def process_raw_data(self) -> None: ) def _load_dataset(self) -> Tuple[torch.Tensor, torch.Tensor]: + """Load the dataset from the raw data file. + + Returns: + data_train, targets_train, data_test, targets_test + tuple: A tuple containing the data tensor and the target tensor. + + Examples: + >>> data, targets = dataset._load_dataset() + >>> data.shape + torch.Size([528, 10]) + >>> targets.shape + torch.Size([528]) + """ + data = [] targets = [] with open(os.path.join(self.root, "raw", self.filename), "r") as f: @@ -105,6 +165,21 @@ def _load_dataset(self) -> Tuple[torch.Tensor, torch.Tensor]: return data, targets def _split_dataset(self, data: Tensor, targets: Tensor) -> Tuple[Tensor, ...]: + """Split the dataset into training and test sets. + + Args: + data (torch.Tensor): The input data tensor. + targets (torch.Tensor): The target tensor. + + Returns: + tuple: A tuple containing the training data, training targets, test data, and test targets. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> data, targets = dataset._load_dataset() + >>> data_train, targets_train, data_test, targets_test = dataset._split_dataset(data, targets) + """ + from sklearn.model_selection import train_test_split data_train, data_test, targets_train, targets_test = train_test_split( @@ -119,6 +194,22 @@ def _split_dataset(self, data: Tensor, targets: Tensor) -> Tuple[Tensor, ...]: def _preprocess_dataset( self, data_train: Tensor, data_test: Tensor ) -> Tuple[Tensor, Tensor]: + """Preprocess the dataset by applying PCA and scaling transformations. + + Args: + data_train (torch.Tensor): The training data tensor. + data_test (torch.Tensor): The test data tensor. + + Returns: + tuple: A tuple containing the preprocessed training data and test data. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> data, targets = dataset._load_dataset() + >>> data_train, targets_train, data_test, targets_test = dataset._split_dataset(data, targets) + >>> preprocessed_train_data, preprocessed_test_data = dataset._preprocess_dataset(data_train, data_test) + """ + from sklearn.decomposition import PCA from sklearn.preprocessing import MinMaxScaler, RobustScaler @@ -149,6 +240,27 @@ def _save_dataset( targets_test: Tensor, processed_dir: str, ) -> None: + """Save the preprocessed dataset to disk. + + Args: + data_train (torch.Tensor): The preprocessed training data tensor. + targets_train (torch.Tensor): The training targets tensor. + data_test (torch.Tensor): The preprocessed test data tensor. + targets_test (torch.Tensor): The test targets tensor. + processed_dir (str): The directory to save the processed dataset. + + Returns: + None. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> data, targets = dataset._load_dataset() + >>> data_train, targets_train, data_test, targets_test = dataset._split_dataset(data, targets) + >>> preprocessed_train_data, preprocessed_test_data = dataset._preprocess_dataset(data_train, data_test) + >>> dataset._save_dataset(preprocessed_train_data, targets_train, preprocessed_test_data, targets_test, 'processed') + Processed dataset saved + """ + os.makedirs(processed_dir, exist_ok=True) processed_training_file = os.path.join(processed_dir, "training.pt") processed_test_file = os.path.join(processed_dir, "test.pt") @@ -160,6 +272,23 @@ def _save_dataset( print(f"Processed dataset saved") def load(self, train: bool = True): + """Load the dataset. + + This method loads the dataset from the processed data and returns the data and target labels. + + Args: + train (bool, optional): Determines whether to load the training set or the test set. + Defaults to True (training set). + + Returns: + data: Loaded data. + targets: Target labels. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> data, targets = dataset.load(train=True) + """ + filename = "training.pt" if train else "test.pt" with open(os.path.join(self.root, "processed", filename), "rb") as f: data, targets = torch.load(f) @@ -170,6 +299,18 @@ def load(self, train: bool = True): return data, targets def download(self) -> None: + """Download the dataset. + + This method downloads the dataset from the internet and places it in the root directory. + + Returns: + None + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> dataset.download() + """ + if self._check_integrity(): print("Files already downloaded and verified") return @@ -178,19 +319,82 @@ def download(self) -> None: ) def _check_integrity(self) -> bool: + """Check the integrity of the dataset. + + This method checks if the dataset exists and is not corrupted. + + Returns: + bool: True if the dataset is found and intact, False otherwise. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> dataset._check_integrity() + True + """ + return os.path.exists(os.path.join(self.root, "raw", self.filename)) def __len__(self): + """Get the number of items in the dataset. + + Returns: + int: Number of items in the dataset. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> len(dataset) + 143 + """ + return self.targets.size(0) def __getitem__(self, item): + """Get a specific item from the dataset. + + Args: + index (int): Index of the item. + + Returns: + tuple: A tuple containing the transformed item data and its corresponding target class index. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> img, target = dataset[0] + """ + return self.data[item], self.targets[item] def extra_repr(self) -> str: + """Return a string representation of the dataset's split (train or test). + + Returns: + str: A string indicating the dataset's split. + + Examples: + >>> dataset = VowelRecognition(root='data', train=True, transform=None, download=True) + >>> dataset.extra_repr() + 'Split: Train' + """ + return "Split: {}".format("Train" if self.train is True else "Test") class VowelRecognitionDataset: + """Vowel Recognition dataset. + + Attributes: + root (str): Root directory of the dataset. + split (str): Split name ('train', 'valid', or 'test'). + test_ratio (float): Ratio of data to use for testing. + train_valid_split_ratio (List[float]): Ratio of data to use for training and validation split. + data (Dataset): Loaded dataset. + resize (int): Size to resize the input data. + binarize (bool): Whether to binarize the input data. + binarize_threshold (float): Threshold value for binarization. + digits_of_interest (List[int]): List of digits of interest. + n_instance (int): Number of instances in the dataset. + """ + def __init__( self, root: str, @@ -202,6 +406,37 @@ def __init__( binarize_threshold: float, digits_of_interest: List[int], ): + """Initialize Vowel Recognition dataset. + + Args: + root (str): Root directory of the dataset. + split (str): Split name ('train', 'valid', or 'test'). + test_ratio (float): Ratio of data to use for testing. + train_valid_split_ratio (List[float]): Ratio of data to use for training and validation split. + resize (int): Size to resize the input data. + binarize (bool): Whether to binarize the input data. + binarize_threshold (float): Threshold value for binarization. + digits_of_interest (List[int]): List of digits of interest. + + Returns: + None. + + Raises: + AssertionError: If `test_ratio` is not within the range (0, 1). + + Examples: + >>> dataset = VowelRecognitionDataset( + >>> root='data', + >>> split='train', + >>> test_ratio=0.2, + >>> train_valid_split_ratio=[0.8, 0.2], + >>> resize=32, + >>> binarize=True, + >>> binarize_threshold=0.5, + >>> digits_of_interest=[0, 1, 2], + >>> ) + """ + self.root = root self.split = split self.test_ratio = test_ratio @@ -219,6 +454,12 @@ def __init__( self.n_instance = len(self.data) def load(self): + """Load the dataset based on the split and other parameters. + + Returns: + None. + """ + tran = [transforms.ToTensor()] transform = transforms.Compose(tran) @@ -266,6 +507,18 @@ def load(self): self.data = test def __getitem__(self, index: int) -> Dict[str, Tensor]: + """Get a specific instance from the dataset. + + Args: + index (int): Index of the instance to retrieve. + + Returns: + Dict[str, Tensor]: A dictionary containing the input data and label. + + Examples: + >>> instance = dataset[0] + """ + data = self.data[index][0] if self.binarize: data = 1.0 * (data > self.binarize_threshold) + -1.0 * ( @@ -277,13 +530,42 @@ def __getitem__(self, index: int) -> Dict[str, Tensor]: return instance def __len__(self) -> int: + """Get the number of instances in the dataset. + + Returns: + int: Number of instances in the dataset. + + Examples: + >>> len(dataset) + 10000 + """ + return len(self.data) def __call__(self, index: int) -> Dict[str, Tensor]: + """Call the dataset to retrieve a specific instance. + + Args: + index (int): Index of the instance to retrieve. + + Returns: + Dict[str, Tensor]: A dictionary containing the input data and label. + + Examples: + >>> instance = dataset(0) + """ + return self.__getitem__(index) class Vowel(Dataset): + """Vowel dataset. + + Attributes: + root (str): Root directory of the dataset. + splits (Dict[str, VowelRecognitionDataset]): Dictionary of dataset splits. + """ + def __init__( self, root: str, @@ -294,6 +576,28 @@ def __init__( binarize_threshold=0.1307, digits_of_interest=tuple(range(10)), ): + """Initialize Vowel dataset. + + Args: + root (str): Root directory of the dataset. + test_ratio (float): Ratio of test examples. + train_valid_split_ratio (List[float]): Ratios of train and validation examples. + resize (int, optional): Size to resize the images. + Defaults to 28. + binarize (bool, optional): Whether to binarize the images. + Defaults to False. + binarize_threshold (float, optional): Threshold for binarization. + Defaults to 0.1307. + digits_of_interest (Tuple[int], optional): Tuple of digits to include. + Defaults to tuple(range(10)). + + Returns: + None. + + Examples: + >>> dataset = Vowel(root='data', test_ratio=0.2, train_valid_split_ratio=[0.8, 0.2]) + """ + self.root = root super().__init__( @@ -314,6 +618,15 @@ def __init__( def test_vowel(): + """Test the Vowel dataset. + + Returns: + None. + + Examples: + >>> test_vowel() + """ + import pdb pdb.set_trace() From 13c77c99f1812b366e05ad057c15c427f9d75628 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Denise/Den=C4=8Da?= <95103224+denvitko@users.noreply.github.com> Date: Tue, 13 Jun 2023 18:02:24 +0200 Subject: [PATCH 003/106] added a few docstrings --- torchquantum/super_layers.py | 62 ++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/torchquantum/super_layers.py b/torchquantum/super_layers.py index 85f601d7..0722621e 100644 --- a/torchquantum/super_layers.py +++ b/torchquantum/super_layers.py @@ -18,6 +18,30 @@ def get_combs(inset: List, n=None) -> List[List]: + """Get all combinations of elements from `inset`. + + Args: + inset (List): List of elements. + n (int or Iterable, optional): Number of elements to include in each combination. + If `n` is an integer, only combinations of that size will be returned. + If `n` is an iterable, combinations of different sizes specified by `n` will be returned. + If `n` is not provided, all possible combinations with different numbers of elements will be returned. + Defaults to None. + + Returns: + List[List]: List of all combinations of elements from `inset`. + + Examples: + >>> get_combs([1, 2, 3]) + [[1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]] + + >>> get_combs([1, 2, 3], n=2) + [[1, 2], [1, 3], [2, 3]] + + >>> get_combs([1, 2, 3], n=[1, 2]) + [[1], [2], [3], [1, 2], [1, 3], [2, 3]] + """ + all_combs = [] if n is None: # all possible combinations, with different #elements in a set @@ -33,19 +57,57 @@ def get_combs(inset: List, n=None) -> List[List]: class SuperQuantumModule(tq.QuantumModule): + """A super module for quantum computations. + + Attributes: + n_wires (int): Number of wires in the quantum module. + sample_arch: The sample architecture for the quantum module. + + Methods: + set_sample_arch(sample_arch): Sets the sample architecture for the quantum module. + count_sample_params(): Counts the number of sample parameters in the quantum module. + """ + def __init__(self, n_wires): + """Initializes the SuperQuantumModule. + + Args: + n_wires (int): Number of wires in the quantum module. + """ + super().__init__() self.n_wires = n_wires self.sample_arch = None def set_sample_arch(self, sample_arch): + """Set the sample architecture for the quantum module. + + Args: + sample_arch: The sample architecture for the quantum module. + + Returns: + None. + """ + self.sample_arch = sample_arch @property def arch_space(self): + """Return the architecture space of the quantum module. + + Returns: + None. + """ + return None def count_sample_params(self): + """Count the number of sample parameters in the quantum module. + + Raises: + NotImplementedError + """ + raise NotImplementedError From 0c3deffd886c3d65bc698fd52085084eff9df002 Mon Sep 17 00:00:00 2001 From: Sergii Dymchenko Date: Tue, 18 Jul 2023 18:02:44 -0700 Subject: [PATCH 004/106] Update deprecated torch.range and torch.outer --- examples/gradient_pruning/q_models.py | 4 ++-- torchquantum/pulse/utils.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/gradient_pruning/q_models.py b/examples/gradient_pruning/q_models.py index aae5a896..2cde7f2c 100644 --- a/examples/gradient_pruning/q_models.py +++ b/examples/gradient_pruning/q_models.py @@ -130,7 +130,7 @@ def shift_and_run( node.shift_this_step[idx] = True elif self.pruning_method == "perlayer_pruning": node.shift_this_step[:] = False - idxs = torch.range(0, self.n_params - 1, dtype=int).view( + idxs = torch.arange(0, self.n_params, dtype=int).view( self.n_qubits, self.n_layers ) sampled_colums = self.colums @@ -140,7 +140,7 @@ def shift_and_run( self.colums %= self.n_layers elif self.pruning_method == "perqubit_pruning": node.shift_this_step[:] = False - idxs = torch.range(0, self.n_params - 1, dtype=int).view( + idxs = torch.arange(0, self.n_params, dtype=int).view( self.n_qubits, self.n_layers ) sampled_rows = self.rows diff --git a/torchquantum/pulse/utils.py b/torchquantum/pulse/utils.py index e80465c2..eb0c7b82 100644 --- a/torchquantum/pulse/utils.py +++ b/torchquantum/pulse/utils.py @@ -40,7 +40,7 @@ def InitialState(n_qubit = 1, state = [0]): def InitialDensity(n_qubit = 1, state = [0]): initial_state = InitialState(n_qubit, state) - initial_density = torch.ger(initial_state, torch.conj(initial_state)) + initial_density = torch.outer(initial_state, torch.conj(initial_state)) return initial_density def H_2q_example(pulse, dt): From c1efb86a35e1647c151a85fdd09a8428e80dae91 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Wed, 30 Aug 2023 15:45:56 -0400 Subject: [PATCH 005/106] separated hadamard from rest --- torchquantum/operator/hadamard.py | 43 +++ torchquantum/operator/op_types.py | 452 +++++++++++++++++++++++++++ torchquantum/operator/operators.py | 481 +---------------------------- 3 files changed, 498 insertions(+), 478 deletions(-) create mode 100644 torchquantum/operator/hadamard.py create mode 100644 torchquantum/operator/op_types.py diff --git a/torchquantum/operator/hadamard.py b/torchquantum/operator/hadamard.py new file mode 100644 index 00000000..0fe4046f --- /dev/null +++ b/torchquantum/operator/hadamard.py @@ -0,0 +1,43 @@ +from .op_types import * +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional.functionals as tqf +import numpy as np +from abc import ABCMeta +from ..macro import C_DTYPE, F_DTYPE +from torchquantum.functional import mat_dict + + +class Hadamard(Observable, metaclass=ABCMeta): + """Class for Hadamard Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + matrix = mat_dict["hadamard"] + func = staticmethod(tqf.hadamard) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + def diagonalizing_gates(self): + return [tq.RY(has_params=True, trainable=False, init_params=-np.pi / 4)] + + +class SHadamard(Operation, metaclass=ABCMeta): + """Class for SHadamard Gate.""" + + num_params = 0 + num_wires = 1 + matrix = mat_dict["shadamard"] + func = staticmethod(tqf.shadamard) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/op_types.py b/torchquantum/operator/op_types.py new file mode 100644 index 00000000..a400d5e9 --- /dev/null +++ b/torchquantum/operator/op_types.py @@ -0,0 +1,452 @@ +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional.functionals as tqf +import numpy as np +from abc import ABCMeta +from ..macro import C_DTYPE, F_DTYPE +from typing import Iterable, Union, List + + +class Operator(tq.QuantumModule): + """The class for quantum operators.""" + + fixed_ops = [ + "Hadamard", + "SHadamard", + "PauliX", + "PauliY", + "PauliZ", + "I", + "S", + "T", + "SX", + "CNOT", + "CZ", + "CY", + "SWAP", + "SSWAP", + "CSWAP", + "Toffoli", + "MultiCNOT", + "MultiXCNOT", + "Reset", + "EchoedCrossResonance", + ] + + parameterized_ops = [ + "RX", + "RY", + "RZ", + "RXX", + "RYY", + "RZZ", + "RZX", + "PhaseShift", + "Rot", + "MultiRZ", + "CRX", + "CRY", + "CRZ", + "CRot", + "U1", + "U2", + "U3", + "CU1", + "CU2", + "CU3", + "QubitUnitary", + "QubitUnitaryFast", + "TrainableUnitary", + "TrainableUnitaryStrict", + "SingleExcitation", + ] + + @property + def name(self): + """String for the name of the operator.""" + return self._name + + @name.setter + def name(self, value): + """Set the name of the operator. + + Args: + value (str): operator name. + + """ + self._name = value + + def __init__( + self, + has_params: bool = False, + trainable: bool = False, + init_params=None, + n_wires=None, + wires=None, + inverse=False, + ): + """__init__ function for Operator. + + Args: + has_params (bool, optional): Whether the operations has parameters. + Defaults to False. + trainable (bool, optional): Whether the parameters are trainable + (if contains parameters). Defaults to False. + init_params (torch.Tensor, optional): Initial parameters. + Defaults to None. + n_wires (int, optional): Number of qubits. Defaults to None. + wires (Union[int, List[int]], optional): Which qubit the operation + is applied to. Defaults to None. + """ + super().__init__() + self.params = None + # number of wires of the operator + # n_wires is used in gates that can be applied to arbitrary number + # of qubits such as MultiRZ + self.n_wires = n_wires + # wires that the operator applies to + self.wires = wires + self._name = self.__class__.__name__ + # for static mode + self.static_matrix = None + self.inverse = inverse + self.clifford_quantization = False + + try: + assert not (trainable and not has_params) + except AssertionError: + has_params = True + logger.warning( + f"Module must have parameters to be trainable; " + f"Switched 'has_params' to True." + ) + + self.has_params = has_params + self.trainable = trainable + if self.has_params: + self.params = self.build_params(trainable=self.trainable) + self.reset_params(init_params) + + @classmethod + def _matrix(cls, params): + """The unitary matrix of the operator. + + Args: + params (torch.Tensor, optional): The parameters for parameterized + operators. + + Returns: None. + + """ + raise NotImplementedError + + @property + def matrix(self): + """The unitary matrix of the operator.""" + return self._matrix(self.params) + + @classmethod + def _eigvals(cls, params): + """The eigenvalues of the unitary matrix of the operator. + + Args: + params (torch.Tensor, optional): The parameters for parameterized + operators. + + Returns: None. + + """ + # Warning: The eigenvalues of the operator {cls.__name__} are not defined. + return None + + @property + def eigvals(self): + """The eigenvalues of the unitary matrix of the operator. + + Returns: Eigenvalues. + + """ + return self._eigvals(self.params) + + def _get_unitary_matrix(self): + """Obtain the unitary matrix of the operator. + + Returns: Unitary matrix. + + """ + return self.matrix + + def set_wires(self, wires): + """Set which qubits the operator is applied to. + + Args: + wires (Union[int, List[int]]): Qubits the operator is applied to. + + Returns: None. + + """ + self.wires = [wires] if isinstance(wires, int) else wires + + def forward( + self, q_device: tq.QuantumDevice, wires=None, params=None, inverse=None + ): + """Apply the operator to the quantum device states. + + Args: + q_device (torchquantum.QuantumDevice): Quantum Device that the + operator is applied to. + wires (Union[int, List[int]]): Qubits that the operator is + applied to. + params (torch.Tensor): Parameters of the operator + inverse (bool): Whether inverse the unitary matrix of the operator. + + Returns: + + """ + if inverse is not None: + logger.warning("replace the inverse flag with the input") + self.inverse = inverse + # try: + # assert self.name in self.fixed_ops or \ + # self.has_params ^ (params is not None) + # except AssertionError as err: + # logger.exception(f"Parameterized gate either has its " + # f"own parameters or has input as parameters") + # raise err + + # try: + # assert not (self.wires is None and wires is None) + # except AssertionError as err: + # logger.exception(f"Need to specify the wires either when " + # f"initialize or when forward") + # raise err + + if params is not None: + self.params = params + + if self.params is not None: + self.params = ( + self.params.unsqueeze(-1) if self.params.dim() == 1 else self.params + ) + + if wires is not None: + # update the wires + wires = [wires] if isinstance(wires, int) else wires + self.wires = wires + + # self.inverse = inverse + + if self.static_mode: + self.parent_graph.add_op(self) + return + + # non-parameterized gate + if self.params is None: + if self.n_wires is None: + self.func(q_device, self.wires, inverse=self.inverse) # type: ignore + else: + self.func(q_device, self.wires, n_wires=self.n_wires, inverse=self.inverse) # type: ignore + else: + if isinstance(self.noise_model_tq, tq.NoiseModelTQPhase): + params = self.noise_model_tq.add_noise(self.params) + else: + params = self.params + + if self.clifford_quantization: + params = CliffordQuantizer.quantize_sse(params) + if self.n_wires is None: + self.func(q_device, self.wires, params=params, inverse=self.inverse) + else: + self.func( + q_device, + self.wires, + params=params, + n_wires=self.n_wires, + inverse=self.inverse, + ) + + if self.noise_model_tq is not None and self.noise_model_tq.is_add_noise: + noise_ops = self.noise_model_tq.sample_noise_op(self) + if len(noise_ops): + for noise_op in noise_ops: + noise_op(q_device) + + def __repr__(self): + return f" class: {self.name} \n parameters: {self.params} \n wires: {self.wires} \n inverse: {self.inverse}" + + +class Observable(Operator, metaclass=ABCMeta): + """Class for Observables.""" + + def __init__( + self, + has_params: bool = False, + trainable: bool = False, + init_params=None, + n_wires=None, + wires=None, + inverse=False, + ): + """Init function of the Observable class + + Args: + has_params (bool, optional): Whether the operations has parameters. + Defaults to False. + trainable (bool, optional): Whether the parameters are trainable + (if contains parameters). Defaults to False. + init_params (torch.Tensor, optional): Initial parameters. + Defaults to None. + n_wires (int, optional): Number of qubits. Defaults to None. + wires (Union[int, List[int]], optional): Which qubit the operation + is applied to. Defaults to None. + """ + super().__init__( + has_params=has_params, + trainable=trainable, + init_params=init_params, + n_wires=n_wires, + wires=wires, + inverse=inverse, + ) + self.return_type = None + + def diagonalizing_gates(self): + """The diagonalizing gates when perform measurements. + + Returns: None. + + """ + raise NotImplementedError + + +class Operation(Operator, metaclass=ABCMeta): + """_summary_""" + + def __init__( + self, + has_params: bool = False, + trainable: bool = False, + init_params=None, + n_wires=None, + wires=None, + inverse=False, + ): + """_summary_ + + Args: + has_params (bool, optional): Whether the operations has parameters. + Defaults to False. + trainable (bool, optional): Whether the parameters are trainable + (if contains parameters). Defaults to False. + init_params (torch.Tensor, optional): Initial parameters. + Defaults to None. + n_wires (int, optional): Number of qubits. Defaults to None. + wires (Union[int, List[int]], optional): Which qubit the operation is applied to. + Defaults to None. + """ + super().__init__( + has_params=has_params, + trainable=trainable, + init_params=init_params, + n_wires=n_wires, + wires=wires, + inverse=inverse, + ) + if type(self.num_wires) == int: + self.n_wires = self.num_wires + + @property + def matrix(self): + """The unitary matrix of the operator.""" + op_matrix = self._matrix(self.params) + + return op_matrix + + @property + def eigvals(self): + """ "The eigenvalues of the unitary matrix of the operator. + + Returns: + torch.Tensor: Eigenvalues. + + """ + op_eigvals = self._eigvals(self.params) + + return op_eigvals + + def init_params(self): + """Initialize the parameters. + + Raises: + NotImplementedError: The init param function is not implemented. + """ + raise NotImplementedError + + def build_params(self, trainable): + """Build parameters. + + Args: + trainable (bool): Whether the parameters are trainable. + + Returns: + torch.Tensor: Built parameters. + """ + parameters = nn.Parameter(torch.empty([1, self.num_params], dtype=F_DTYPE)) + parameters.requires_grad = True if trainable else False + # self.register_parameter(f"{self.name}_params", parameters) + return parameters + + def reset_params(self, init_params=None): + """Reset parameters. + + Args: + init_params (torch.Tensor, optional): Input the initialization + parameters. Defaults to None. + """ + if init_params is not None: + if isinstance(init_params, Iterable): + for k, init_param in enumerate(init_params): + torch.nn.init.constant_(self.params[:, k], init_param) + else: + torch.nn.init.constant_(self.params, init_params) + else: + torch.nn.init.uniform_(self.params, -np.pi, np.pi) + + +class DiagonalOperation(Operation, metaclass=ABCMeta): + """Class for Diagonal Operation.""" + + @classmethod + def _eigvals(cls, params): + """The eigenvalues of the unitary matrix of the operator. + + Args: + params (torch.Tensor, optional): The parameters for parameterized + operators. + + Returns: None. + raise NotImplementedError + """ + + @property + def eigvals(self): + """The eigenvalues of the unitary matrix of the operator. + + Returns: Eigenvalues. + + """ + return super().eigvals + + @classmethod + def _matrix(cls, params): + """The unitary matrix of the operator. + + Args: + params (torch.Tensor, optional): The parameters for parameterized + operators. + + Returns: None. + + """ + return torch.diag(cls._eigvals(params)) diff --git a/torchquantum/operator/operators.py b/torchquantum/operator/operators.py index 90cdfb51..fed6b9f1 100644 --- a/torchquantum/operator/operators.py +++ b/torchquantum/operator/operators.py @@ -36,6 +36,9 @@ from torchpack.utils.logging import logger from typing import Iterable, Union, List +from .op_types import * +from .hadamard import * + __all__ = [ "op_name_dict", "Operator", @@ -122,484 +125,6 @@ class NParamsEnum(IntEnum): subsystem. It is equivalent to an integer with value -1.""" -class Operator(tq.QuantumModule): - """The class for quantum operators.""" - - fixed_ops = [ - "Hadamard", - "SHadamard", - "PauliX", - "PauliY", - "PauliZ", - "I", - "S", - "T", - "SX", - "CNOT", - "CZ", - "CY", - "SWAP", - "SSWAP", - "CSWAP", - "Toffoli", - "MultiCNOT", - "MultiXCNOT", - "Reset", - "EchoedCrossResonance", - ] - - parameterized_ops = [ - "RX", - "RY", - "RZ", - "RXX", - "RYY", - "RZZ", - "RZX", - "PhaseShift", - "Rot", - "MultiRZ", - "CRX", - "CRY", - "CRZ", - "CRot", - "U1", - "U2", - "U3", - "CU1", - "CU2", - "CU3", - "QubitUnitary", - "QubitUnitaryFast", - "TrainableUnitary", - "TrainableUnitaryStrict", - "SingleExcitation", - ] - - @property - def name(self): - """String for the name of the operator.""" - return self._name - - @name.setter - def name(self, value): - """Set the name of the operator. - - Args: - value (str): operator name. - - """ - self._name = value - - def __init__( - self, - has_params: bool = False, - trainable: bool = False, - init_params=None, - n_wires=None, - wires=None, - inverse=False - ): - """__init__ function for Operator. - - Args: - has_params (bool, optional): Whether the operations has parameters. - Defaults to False. - trainable (bool, optional): Whether the parameters are trainable - (if contains parameters). Defaults to False. - init_params (torch.Tensor, optional): Initial parameters. - Defaults to None. - n_wires (int, optional): Number of qubits. Defaults to None. - wires (Union[int, List[int]], optional): Which qubit the operation - is applied to. Defaults to None. - """ - super().__init__() - self.params = None - # number of wires of the operator - # n_wires is used in gates that can be applied to arbitrary number - # of qubits such as MultiRZ - self.n_wires = n_wires - # wires that the operator applies to - self.wires = wires - self._name = self.__class__.__name__ - # for static mode - self.static_matrix = None - self.inverse = inverse - self.clifford_quantization = False - - try: - assert not (trainable and not has_params) - except AssertionError: - has_params = True - logger.warning( - f"Module must have parameters to be trainable; " - f"Switched 'has_params' to True." - ) - - self.has_params = has_params - self.trainable = trainable - if self.has_params: - self.params = self.build_params(trainable=self.trainable) - self.reset_params(init_params) - - @classmethod - def _matrix(cls, params): - """The unitary matrix of the operator. - - Args: - params (torch.Tensor, optional): The parameters for parameterized - operators. - - Returns: None. - - """ - raise NotImplementedError - - @property - def matrix(self): - """The unitary matrix of the operator.""" - return self._matrix(self.params) - - @classmethod - def _eigvals(cls, params): - """The eigenvalues of the unitary matrix of the operator. - - Args: - params (torch.Tensor, optional): The parameters for parameterized - operators. - - Returns: None. - - """ - # Warning: The eigenvalues of the operator {cls.__name__} are not defined. - return None - - @property - def eigvals(self): - """The eigenvalues of the unitary matrix of the operator. - - Returns: Eigenvalues. - - """ - return self._eigvals(self.params) - - def _get_unitary_matrix(self): - """Obtain the unitary matrix of the operator. - - Returns: Unitary matrix. - - """ - return self.matrix - - def set_wires(self, wires): - """Set which qubits the operator is applied to. - - Args: - wires (Union[int, List[int]]): Qubits the operator is applied to. - - Returns: None. - - """ - self.wires = [wires] if isinstance(wires, int) else wires - - def forward( - self, q_device: tq.QuantumDevice, wires=None, params=None, inverse=None - ): - """Apply the operator to the quantum device states. - - Args: - q_device (torchquantum.QuantumDevice): Quantum Device that the - operator is applied to. - wires (Union[int, List[int]]): Qubits that the operator is - applied to. - params (torch.Tensor): Parameters of the operator - inverse (bool): Whether inverse the unitary matrix of the operator. - - Returns: - - """ - if inverse is not None: - logger.warning("replace the inverse flag with the input") - self.inverse = inverse - # try: - # assert self.name in self.fixed_ops or \ - # self.has_params ^ (params is not None) - # except AssertionError as err: - # logger.exception(f"Parameterized gate either has its " - # f"own parameters or has input as parameters") - # raise err - - # try: - # assert not (self.wires is None and wires is None) - # except AssertionError as err: - # logger.exception(f"Need to specify the wires either when " - # f"initialize or when forward") - # raise err - - if params is not None: - self.params = params - - if self.params is not None: - self.params = ( - self.params.unsqueeze(-1) if self.params.dim() == 1 else self.params - ) - - if wires is not None: - # update the wires - wires = [wires] if isinstance(wires, int) else wires - self.wires = wires - - # self.inverse = inverse - - if self.static_mode: - self.parent_graph.add_op(self) - return - - # non-parameterized gate - if self.params is None: - if self.n_wires is None: - self.func(q_device, self.wires, inverse=self.inverse) # type: ignore - else: - self.func(q_device, self.wires, n_wires=self.n_wires, inverse=self.inverse) # type: ignore - else: - if isinstance(self.noise_model_tq, tq.NoiseModelTQPhase): - params = self.noise_model_tq.add_noise(self.params) - else: - params = self.params - - if self.clifford_quantization: - params = CliffordQuantizer.quantize_sse(params) - if self.n_wires is None: - self.func(q_device, self.wires, params=params, inverse=self.inverse) - else: - self.func( - q_device, - self.wires, - params=params, - n_wires=self.n_wires, - inverse=self.inverse, - ) - - if self.noise_model_tq is not None and self.noise_model_tq.is_add_noise: - noise_ops = self.noise_model_tq.sample_noise_op(self) - if len(noise_ops): - for noise_op in noise_ops: - noise_op(q_device) - - def __repr__(self): - return f" class: {self.name} \n parameters: {self.params} \n wires: {self.wires} \n inverse: {self.inverse}" - - -class Observable(Operator, metaclass=ABCMeta): - """Class for Observables.""" - - def __init__( - self, - has_params: bool = False, - trainable: bool = False, - init_params=None, - n_wires=None, - wires=None, - inverse=False, - ): - """Init function of the Observable class - - Args: - has_params (bool, optional): Whether the operations has parameters. - Defaults to False. - trainable (bool, optional): Whether the parameters are trainable - (if contains parameters). Defaults to False. - init_params (torch.Tensor, optional): Initial parameters. - Defaults to None. - n_wires (int, optional): Number of qubits. Defaults to None. - wires (Union[int, List[int]], optional): Which qubit the operation - is applied to. Defaults to None. - """ - super().__init__( - has_params=has_params, - trainable=trainable, - init_params=init_params, - n_wires=n_wires, - wires=wires, - inverse=inverse - ) - self.return_type = None - - def diagonalizing_gates(self): - """The diagonalizing gates when perform measurements. - - Returns: None. - - """ - raise NotImplementedError - - -class Operation(Operator, metaclass=ABCMeta): - """_summary_""" - - def __init__( - self, - has_params: bool = False, - trainable: bool = False, - init_params=None, - n_wires=None, - wires=None, - inverse=False - ): - """_summary_ - - Args: - has_params (bool, optional): Whether the operations has parameters. - Defaults to False. - trainable (bool, optional): Whether the parameters are trainable - (if contains parameters). Defaults to False. - init_params (torch.Tensor, optional): Initial parameters. - Defaults to None. - n_wires (int, optional): Number of qubits. Defaults to None. - wires (Union[int, List[int]], optional): Which qubit the operation is applied to. - Defaults to None. - """ - super().__init__( - has_params=has_params, - trainable=trainable, - init_params=init_params, - n_wires=n_wires, - wires=wires, - inverse=inverse - ) - if type(self.num_wires) == int: - self.n_wires = self.num_wires - - @property - def matrix(self): - """The unitary matrix of the operator.""" - op_matrix = self._matrix(self.params) - - return op_matrix - - @property - def eigvals(self): - """ "The eigenvalues of the unitary matrix of the operator. - - Returns: - torch.Tensor: Eigenvalues. - - """ - op_eigvals = self._eigvals(self.params) - - return op_eigvals - - def init_params(self): - """Initialize the parameters. - - Raises: - NotImplementedError: The init param function is not implemented. - """ - raise NotImplementedError - - def build_params(self, trainable): - """Build parameters. - - Args: - trainable (bool): Whether the parameters are trainable. - - Returns: - torch.Tensor: Built parameters. - """ - parameters = nn.Parameter(torch.empty([1, self.num_params], dtype=F_DTYPE)) - parameters.requires_grad = True if trainable else False - # self.register_parameter(f"{self.name}_params", parameters) - return parameters - - def reset_params(self, init_params=None): - """Reset parameters. - - Args: - init_params (torch.Tensor, optional): Input the initialization - parameters. Defaults to None. - """ - if init_params is not None: - if isinstance(init_params, Iterable): - for k, init_param in enumerate(init_params): - torch.nn.init.constant_(self.params[:, k], init_param) - else: - torch.nn.init.constant_(self.params, init_params) - else: - torch.nn.init.uniform_(self.params, -np.pi, np.pi) - - -class DiagonalOperation(Operation, metaclass=ABCMeta): - """Class for Diagonal Operation.""" - - @classmethod - def _eigvals(cls, params): - """The eigenvalues of the unitary matrix of the operator. - - Args: - params (torch.Tensor, optional): The parameters for parameterized - operators. - - Returns: None. - raise NotImplementedError - """ - - @property - def eigvals(self): - """The eigenvalues of the unitary matrix of the operator. - - Returns: Eigenvalues. - - """ - return super().eigvals - - @classmethod - def _matrix(cls, params): - """The unitary matrix of the operator. - - Args: - params (torch.Tensor, optional): The parameters for parameterized - operators. - - Returns: None. - - """ - return torch.diag(cls._eigvals(params)) - - -class Hadamard(Observable, metaclass=ABCMeta): - """Class for Hadamard Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, -1], dtype=C_DTYPE) - matrix = mat_dict["hadamard"] - func = staticmethod(tqf.hadamard) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - def diagonalizing_gates(self): - return [tq.RY(has_params=True, trainable=False, init_params=-np.pi / 4)] - - -class SHadamard(Operation, metaclass=ABCMeta): - """Class for SHadamard Gate.""" - - num_params = 0 - num_wires = 1 - matrix = mat_dict["shadamard"] - func = staticmethod(tqf.shadamard) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - class PauliX(Observable, metaclass=ABCMeta): """Class for Pauli X Gate.""" From 61628a1b4113235405e5715a4faff07308d831e9 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Wed, 30 Aug 2023 16:08:01 -0400 Subject: [PATCH 006/106] updated operators for the new dev --- torchquantum/operator/op_types.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/torchquantum/operator/op_types.py b/torchquantum/operator/op_types.py index a400d5e9..6cf59aaa 100644 --- a/torchquantum/operator/op_types.py +++ b/torchquantum/operator/op_types.py @@ -32,6 +32,23 @@ class Operator(tq.QuantumModule): "MultiXCNOT", "Reset", "EchoedCrossResonance", + "QFT", + "SDG", + "TDG", + "SXDG", + "CH", + "CCZ", + "ISWAP", + "CS", + "CSDG", + "CSX", + "CHadamard", + "DCX", + "C3X", + "C3SX", + "RCCX", + "RC3X", + "C4X", ] parameterized_ops = [ @@ -52,6 +69,7 @@ class Operator(tq.QuantumModule): "U1", "U2", "U3", + "CU", "CU1", "CU2", "CU3", @@ -60,6 +78,10 @@ class Operator(tq.QuantumModule): "TrainableUnitary", "TrainableUnitaryStrict", "SingleExcitation", + "XXMINYY", + "XXPLUSYY", + "R", + "GlobalPhase", ] @property From 7025a07ba9b67a063c35dab57115bec7ec50a435 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Wed, 30 Aug 2023 21:56:06 -0400 Subject: [PATCH 007/106] separate file for x, y, z, i, s, t, and sx gates --- torchquantum/operator/i.py | 28 +++++ torchquantum/operator/op_hamil_exp.py | 66 ++++++------ torchquantum/operator/operators.py | 145 ++------------------------ torchquantum/operator/paulix.py | 28 +++++ torchquantum/operator/pauliy.py | 28 +++++ torchquantum/operator/pauliz.py | 28 +++++ torchquantum/operator/s.py | 25 +++++ torchquantum/operator/sx.py | 25 +++++ torchquantum/operator/t.py | 25 +++++ 9 files changed, 227 insertions(+), 171 deletions(-) create mode 100644 torchquantum/operator/i.py create mode 100644 torchquantum/operator/paulix.py create mode 100644 torchquantum/operator/pauliy.py create mode 100644 torchquantum/operator/pauliz.py create mode 100644 torchquantum/operator/s.py create mode 100644 torchquantum/operator/sx.py create mode 100644 torchquantum/operator/t.py diff --git a/torchquantum/operator/i.py b/torchquantum/operator/i.py new file mode 100644 index 00000000..0c73e4dd --- /dev/null +++ b/torchquantum/operator/i.py @@ -0,0 +1,28 @@ +from .op_types import Observable +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class I(Observable, metaclass=ABCMeta): + """Class for Identity Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, 1], dtype=C_DTYPE) + matrix = mat_dict["i"] + func = staticmethod(tqf.i) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + def diagonalizing_gates(self): + return [] diff --git a/torchquantum/operator/op_hamil_exp.py b/torchquantum/operator/op_hamil_exp.py index e9e16809..a8cec8bb 100644 --- a/torchquantum/operator/op_hamil_exp.py +++ b/torchquantum/operator/op_hamil_exp.py @@ -32,9 +32,9 @@ import numpy as np __all__ = [ - 'OpHamilExp', - 'OpPauliExp', - ] + "OpHamilExp", + "OpPauliExp", +] class OpHamilExp(QuantumModule): @@ -42,18 +42,16 @@ class OpHamilExp(QuantumModule): exp(-i * theta * H / 2) the default theta is 0.0 """ - def __init__(self, - hamil: Hamiltonian, - trainable: bool = True, - theta: float = 0.0): + + def __init__(self, hamil: Hamiltonian, trainable: bool = True, theta: float = 0.0): """Initialize the OpHamilExp module. - + Args: hamil: The Hamiltonian. has_params: Whether the module has parameters. trainable: Whether the parameters are trainable. theta: The initial value of theta. - + """ super().__init__() if trainable: @@ -61,11 +59,11 @@ def __init__(self, else: self.theta = torch.tensor(theta) self.hamil = hamil - + def get_exponent_matrix(self): """Get the matrix on exponent.""" return self.hamil.matrix * -1j * self.theta / 2 - + @property def exponent_matrix(self): """Get the matrix on exponent.""" @@ -74,12 +72,12 @@ def exponent_matrix(self): def get_matrix(self): """Get the overall matrix.""" return torch.matrix_exp(self.exponent_matrix) - + @property def matrix(self): """Get the overall matrix.""" return self.get_matrix() - + def forward(self, qdev, wires): """Forward the OpHamilExp module. Args: @@ -96,21 +94,23 @@ def forward(self, qdev, wires): class OpPauliExp(OpHamilExp): - def __init__(self, - coeffs: List[float], - paulis: List[str], - endianness: str = "big", - trainable: bool = True, - theta: float = 0.0): + def __init__( + self, + coeffs: List[float], + paulis: List[str], + endianness: str = "big", + trainable: bool = True, + theta: float = 0.0, + ): """Initialize the OpPauliExp module. - + Args: coeffs: The coefficients of the Hamiltonian. paulis: The operators of the Hamiltonian, described in strings. endianness: The endianness of the operators. Default is big. Qubit 0 is the most significant bit. trainable: Whether the parameters are trainable. theta: The initial value of theta. - + """ self.hamil = Hamiltonian(coeffs, paulis, endianness) super().__init__( @@ -121,7 +121,7 @@ def __init__(self, self.coeffs = coeffs self.paulis = paulis self.trainable = trainable - + def forward(self, qdev, wires): """Forward the OpHamilExp module. Args: @@ -132,17 +132,17 @@ def forward(self, qdev, wires): matrix = self.matrix.to(qdev.device) if qdev.record_op: qdev.op_history.append( - { - "name": self.__class__.__name__, # type: ignore - "wires": np.array(wires).squeeze().tolist(), - "coeffs": self.coeffs, - "paulis": self.paulis, - "inverse": False, - "trainable": self.trainable, - "params": self.theta.item(), - } - ) - + { + "name": self.__class__.__name__, # type: ignore + "wires": np.array(wires).squeeze().tolist(), + "coeffs": self.coeffs, + "paulis": self.paulis, + "inverse": False, + "trainable": self.trainable, + "params": self.theta.item(), + } + ) + tqf.qubitunitaryfast( q_device=qdev, wires=wires, diff --git a/torchquantum/operator/operators.py b/torchquantum/operator/operators.py index dce5bd23..05a2cd27 100644 --- a/torchquantum/operator/operators.py +++ b/torchquantum/operator/operators.py @@ -38,6 +38,13 @@ from .op_types import * from .hadamard import * +from .paulix import * +from .pauliy import * +from .pauliz import * +from .i import * +from .s import * +from .t import * +from .sx import * __all__ = [ "op_name_dict", @@ -148,144 +155,6 @@ class NParamsEnum(IntEnum): subsystem. It is equivalent to an integer with value -1.""" -class PauliX(Observable, metaclass=ABCMeta): - """Class for Pauli X Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, -1], dtype=C_DTYPE) - matrix = mat_dict["paulix"] - func = staticmethod(tqf.paulix) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - def diagonalizing_gates(self): - return [tq.Hadamard()] - - -class PauliY(Observable, metaclass=ABCMeta): - """Class for Pauli Y Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, -1], dtype=C_DTYPE) - matrix = mat_dict["pauliy"] - func = staticmethod(tqf.pauliy) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - def diagonalizing_gates(self): - return [tq.PauliZ(), tq.S(), tq.Hadamard()] - - -class PauliZ(Observable, metaclass=ABCMeta): - """Class for Pauli Z Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, -1], dtype=C_DTYPE) - matrix = mat_dict["pauliz"] - func = staticmethod(tqf.pauliz) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - def diagonalizing_gates(self): - return [] - - -class I(Observable, metaclass=ABCMeta): - """Class for Identity Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, 1], dtype=C_DTYPE) - matrix = mat_dict["i"] - func = staticmethod(tqf.i) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - def diagonalizing_gates(self): - return [] - - -class S(DiagonalOperation, metaclass=ABCMeta): - """Class for S Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) - matrix = mat_dict["s"] - func = staticmethod(tqf.s) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - -class T(DiagonalOperation, metaclass=ABCMeta): - """Class for T Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) - matrix = mat_dict["t"] - func = staticmethod(tqf.t) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - -class SX(Operation, metaclass=ABCMeta): - """Class for SX Gate.""" - - num_params = 0 - num_wires = 1 - eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) - matrix = mat_dict["sx"] - func = staticmethod(tqf.sx) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - class CNOT(Operation, metaclass=ABCMeta): """Class for CNOT Gate.""" diff --git a/torchquantum/operator/paulix.py b/torchquantum/operator/paulix.py new file mode 100644 index 00000000..92b98911 --- /dev/null +++ b/torchquantum/operator/paulix.py @@ -0,0 +1,28 @@ +from .op_types import Observable +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class PauliX(Observable, metaclass=ABCMeta): + """Class for Pauli X Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + matrix = mat_dict["paulix"] + func = staticmethod(tqf.paulix) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + def diagonalizing_gates(self): + return [tq.Hadamard()] diff --git a/torchquantum/operator/pauliy.py b/torchquantum/operator/pauliy.py new file mode 100644 index 00000000..36569640 --- /dev/null +++ b/torchquantum/operator/pauliy.py @@ -0,0 +1,28 @@ +from .op_types import Observable +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class PauliY(Observable, metaclass=ABCMeta): + """Class for Pauli Y Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + matrix = mat_dict["pauliy"] + func = staticmethod(tqf.pauliy) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + def diagonalizing_gates(self): + return [tq.PauliZ(), tq.S(), tq.Hadamard()] diff --git a/torchquantum/operator/pauliz.py b/torchquantum/operator/pauliz.py new file mode 100644 index 00000000..d314afd2 --- /dev/null +++ b/torchquantum/operator/pauliz.py @@ -0,0 +1,28 @@ +from .op_types import Observable +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class PauliZ(Observable, metaclass=ABCMeta): + """Class for Pauli Z Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + matrix = mat_dict["pauliz"] + func = staticmethod(tqf.pauliz) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + def diagonalizing_gates(self): + return [] diff --git a/torchquantum/operator/s.py b/torchquantum/operator/s.py new file mode 100644 index 00000000..9189f544 --- /dev/null +++ b/torchquantum/operator/s.py @@ -0,0 +1,25 @@ +from .op_types import DiagonalOperation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class S(DiagonalOperation, metaclass=ABCMeta): + """Class for S Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) + matrix = mat_dict["s"] + func = staticmethod(tqf.s) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals diff --git a/torchquantum/operator/sx.py b/torchquantum/operator/sx.py new file mode 100644 index 00000000..d91a6d71 --- /dev/null +++ b/torchquantum/operator/sx.py @@ -0,0 +1,25 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class SX(Operation, metaclass=ABCMeta): + """Class for SX Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) + matrix = mat_dict["sx"] + func = staticmethod(tqf.sx) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals diff --git a/torchquantum/operator/t.py b/torchquantum/operator/t.py new file mode 100644 index 00000000..01634eb6 --- /dev/null +++ b/torchquantum/operator/t.py @@ -0,0 +1,25 @@ +from .op_types import DiagonalOperation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class T(DiagonalOperation, metaclass=ABCMeta): + """Class for T Gate.""" + + num_params = 0 + num_wires = 1 + eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) + matrix = mat_dict["t"] + func = staticmethod(tqf.t) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals From dbcfea4c4e68c4aa03c1beb26571903895ff9dc2 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Wed, 30 Aug 2023 22:54:12 -0400 Subject: [PATCH 008/106] reformatting operations into separate files --- torchquantum/operator/ecr.py | 23 + torchquantum/operator/global_phase.py | 19 + torchquantum/operator/hadamard.py | 18 + torchquantum/operator/iswap.py | 20 + torchquantum/operator/op_types.py | 30 + torchquantum/operator/operators.py | 956 +-------------------- torchquantum/operator/paulix.py | 88 +- torchquantum/operator/pauliy.py | 15 +- torchquantum/operator/pauliz.py | 38 +- torchquantum/operator/phase_shift.py | 19 + torchquantum/operator/qft.py | 19 + torchquantum/operator/qubit_unitary.py | 151 ++++ torchquantum/operator/r.py | 19 + torchquantum/operator/reset.py | 19 + torchquantum/operator/rot.py | 31 + torchquantum/operator/rx.py | 43 + torchquantum/operator/ry.py | 43 + torchquantum/operator/rz.py | 67 ++ torchquantum/operator/s.py | 52 +- torchquantum/operator/single_excitation.py | 19 + torchquantum/operator/swap.py | 46 + torchquantum/operator/sx.py | 39 + torchquantum/operator/t.py | 15 +- torchquantum/operator/toffoli.py | 46 + torchquantum/operator/trainable_unitary.py | 58 ++ torchquantum/operator/u.py | 19 + torchquantum/operator/u1.py | 33 + torchquantum/operator/u2.py | 31 + torchquantum/operator/u3.py | 31 + torchquantum/operator/xx_min_yy.py | 19 + torchquantum/operator/xx_plus_yy.py | 19 + 31 files changed, 1106 insertions(+), 939 deletions(-) create mode 100644 torchquantum/operator/ecr.py create mode 100644 torchquantum/operator/global_phase.py create mode 100644 torchquantum/operator/iswap.py create mode 100644 torchquantum/operator/phase_shift.py create mode 100644 torchquantum/operator/qft.py create mode 100644 torchquantum/operator/qubit_unitary.py create mode 100644 torchquantum/operator/r.py create mode 100644 torchquantum/operator/reset.py create mode 100644 torchquantum/operator/rot.py create mode 100644 torchquantum/operator/rx.py create mode 100644 torchquantum/operator/ry.py create mode 100644 torchquantum/operator/rz.py create mode 100644 torchquantum/operator/single_excitation.py create mode 100644 torchquantum/operator/swap.py create mode 100644 torchquantum/operator/toffoli.py create mode 100644 torchquantum/operator/trainable_unitary.py create mode 100644 torchquantum/operator/u.py create mode 100644 torchquantum/operator/u1.py create mode 100644 torchquantum/operator/u2.py create mode 100644 torchquantum/operator/u3.py create mode 100644 torchquantum/operator/xx_min_yy.py create mode 100644 torchquantum/operator/xx_plus_yy.py diff --git a/torchquantum/operator/ecr.py b/torchquantum/operator/ecr.py new file mode 100644 index 00000000..cba13546 --- /dev/null +++ b/torchquantum/operator/ecr.py @@ -0,0 +1,23 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class ECR(Operation, metaclass=ABCMeta): + """Class for Echoed Cross Resonance Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["ecr"] + func = staticmethod(tqf.ecr) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +EchoedCrossResonance = ECR diff --git a/torchquantum/operator/global_phase.py b/torchquantum/operator/global_phase.py new file mode 100644 index 00000000..e1b8512d --- /dev/null +++ b/torchquantum/operator/global_phase.py @@ -0,0 +1,19 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class GlobalPhase(Operation, metaclass=ABCMeta): + """Class for Global Phase gate.""" + + num_params = 1 + num_wires = 0 + func = staticmethod(tqf.globalphase) + + @classmethod + def _matrix(cls, params): + return tqf.globalphase_matrix(params) diff --git a/torchquantum/operator/hadamard.py b/torchquantum/operator/hadamard.py index 0fe4046f..ce447f8d 100644 --- a/torchquantum/operator/hadamard.py +++ b/torchquantum/operator/hadamard.py @@ -41,3 +41,21 @@ class SHadamard(Operation, metaclass=ABCMeta): @classmethod def _matrix(cls, params): return cls.matrix + + +class CHadamard(Operation, metaclass=ABCMeta): + """Class for CHadamard Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["chadamard"] + func = staticmethod(tqf.chadamard) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +H = Hadamard +SH = SHadamard +CH = CHadamard diff --git a/torchquantum/operator/iswap.py b/torchquantum/operator/iswap.py new file mode 100644 index 00000000..ae8d0504 --- /dev/null +++ b/torchquantum/operator/iswap.py @@ -0,0 +1,20 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class ISWAP(Operation, metaclass=ABCMeta): + """Class for ISWAP Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["iswap"] + func = staticmethod(tqf.iswap) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/op_types.py b/torchquantum/operator/op_types.py index 6cf59aaa..b284cb05 100644 --- a/torchquantum/operator/op_types.py +++ b/torchquantum/operator/op_types.py @@ -6,6 +6,36 @@ from abc import ABCMeta from ..macro import C_DTYPE, F_DTYPE from typing import Iterable, Union, List +from enum import IntEnum + + +class WiresEnum(IntEnum): + """Integer enumeration class + to represent the number of wires + an operation acts on.""" + + AnyWires = -1 + AllWires = 0 + + +class NParamsEnum(IntEnum): + """Integer enumeration class + to represent the number of wires + an operation acts on""" + + AnyNParams = -1 + + +AnyNParams = NParamsEnum.AnyNParams + + +AllWires = WiresEnum.AllWires +"""IntEnum: An enumeration which represents all wires in the +subsystem. It is equivalent to an integer with value 0.""" + +AnyWires = WiresEnum.AnyWires +"""IntEnum: An enumeration which represents any wires in the +subsystem. It is equivalent to an integer with value -1.""" class Operator(tq.QuantumModule): diff --git a/torchquantum/operator/operators.py b/torchquantum/operator/operators.py index 05a2cd27..c74b7c79 100644 --- a/torchquantum/operator/operators.py +++ b/torchquantum/operator/operators.py @@ -45,6 +45,28 @@ from .s import * from .t import * from .sx import * +from .swap import * +from .toffoli import * +from .rx import * +from .ry import * +from .rz import * +from .r import * +from .iswap import * +from .ecr import * +from .single_excitation import * +from .global_phase import * +from .phase_shift import * +from .rot import * +from .trainable_unitary import * +from .qft import * +from .xx_min_yy import * +from .xx_plus_yy import * +from .reset import * +from .qubit_unitary import * +from .u import * +from .u1 import * +from .u2 import * +from .u3 import * __all__ = [ "op_name_dict", @@ -126,940 +148,6 @@ ] -class WiresEnum(IntEnum): - """Integer enumeration class - to represent the number of wires - an operation acts on.""" - - AnyWires = -1 - AllWires = 0 - - -class NParamsEnum(IntEnum): - """Integer enumeration class - to represent the number of wires - an operation acts on""" - - AnyNParams = -1 - - -AnyNParams = NParamsEnum.AnyNParams - - -AllWires = WiresEnum.AllWires -"""IntEnum: An enumeration which represents all wires in the -subsystem. It is equivalent to an integer with value 0.""" - -AnyWires = WiresEnum.AnyWires -"""IntEnum: An enumeration which represents any wires in the -subsystem. It is equivalent to an integer with value -1.""" - - -class CNOT(Operation, metaclass=ABCMeta): - """Class for CNOT Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["cnot"] - func = staticmethod(tqf.cnot) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class CZ(DiagonalOperation, metaclass=ABCMeta): - """Class for CZ Gate.""" - - num_params = 0 - num_wires = 2 - eigvals = np.array([1, 1, 1, -1]) - matrix = mat_dict["cz"] - func = staticmethod(tqf.cz) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - -class CY(Operation, metaclass=ABCMeta): - """Class for CY Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["cy"] - func = staticmethod(tqf.cy) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class SWAP(Operation, metaclass=ABCMeta): - """Class for SWAP Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["swap"] - func = staticmethod(tqf.swap) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class SSWAP(Operation, metaclass=ABCMeta): - """Class for SSWAP Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["sswap"] - func = staticmethod(tqf.sswap) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class CSWAP(Operation, metaclass=ABCMeta): - """Class for CSWAP Gate.""" - - num_params = 0 - num_wires = 3 - matrix = mat_dict["cswap"] - func = staticmethod(tqf.cswap) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class Toffoli(Operation, metaclass=ABCMeta): - """Class for Toffoli Gate.""" - - num_params = 0 - num_wires = 3 - matrix = mat_dict["toffoli"] - func = staticmethod(tqf.toffoli) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class RX(Operation, metaclass=ABCMeta): - """Class for RX Gate.""" - - num_params = 1 - num_wires = 1 - func = staticmethod(tqf.rx) - - @classmethod - def _matrix(cls, params): - return tqf.rx_matrix(params) - - -class RY(Operation, metaclass=ABCMeta): - """Class for RY Gate.""" - - num_params = 1 - num_wires = 1 - func = staticmethod(tqf.ry) - - @classmethod - def _matrix(cls, params): - return tqf.ry_matrix(params) - - -class RZ(DiagonalOperation, metaclass=ABCMeta): - """Class for RZ Gate.""" - - num_params = 1 - num_wires = 1 - func = staticmethod(tqf.rz) - - @classmethod - def _matrix(cls, params): - return tqf.rz_matrix(params) - - -class PhaseShift(DiagonalOperation, metaclass=ABCMeta): - """Class for PhaseShift Gate.""" - - num_params = 1 - num_wires = 1 - func = staticmethod(tqf.phaseshift) - - @classmethod - def _matrix(cls, params): - return tqf.phaseshift_matrix(params) - - -class Rot(Operation, metaclass=ABCMeta): - """Class for Rotation Gate.""" - - num_params = 3 - num_wires = 1 - func = staticmethod(tqf.rot) - - @classmethod - def _matrix(cls, params): - return tqf.rot_matrix(params) - - -class MultiRZ(DiagonalOperation, metaclass=ABCMeta): - """Class for Multi-qubit RZ Gate.""" - - num_params = 1 - num_wires = AnyWires - func = staticmethod(tqf.multirz) - - @classmethod - def _matrix(cls, params, n_wires): - return tqf.multirz_matrix(params, n_wires) - - -class RXX(Operation, metaclass=ABCMeta): - """Class for RXX Gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.rxx) - - @classmethod - def _matrix(cls, params): - return tqf.rxx_matrix(params) - - -class RYY(Operation, metaclass=ABCMeta): - """Class for RYY Gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.ryy) - - @classmethod - def _matrix(cls, params): - return tqf.ryy_matrix(params) - - -class RZZ(DiagonalOperation, metaclass=ABCMeta): - """Class for RZZ Gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.rzz) - - @classmethod - def _matrix(cls, params): - return tqf.rzz_matrix(params) - - -class RZX(Operation, metaclass=ABCMeta): - """Class for RZX Gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.rzx) - - @classmethod - def _matrix(cls, params): - return tqf.rzx_matrix(params) - - -class TrainableUnitary(Operation, metaclass=ABCMeta): - """Class for TrainableUnitary Gate.""" - - num_params = AnyNParams - num_wires = AnyWires - func = staticmethod(tqf.qubitunitaryfast) - - def build_params(self, trainable): - """Build the parameters for the gate. - - Args: - trainable (bool): Whether the parameters are trainble. - - Returns: - torch.Tensor: Parameters. - - """ - parameters = nn.Parameter( - torch.empty(1, 2**self.n_wires, 2**self.n_wires, dtype=C_DTYPE) - ) - parameters.requires_grad = True if trainable else False - # self.register_parameter(f"{self.name}_params", parameters) - return parameters - - def reset_params(self, init_params=None): - """Reset the parameters. - - Args: - init_params (torch.Tensor, optional): Initial parameters. - - Returns: - None. - - """ - mat = torch.randn((1, 2**self.n_wires, 2**self.n_wires), dtype=C_DTYPE) - U, Sigma, V = torch.svd(mat) - self.params.data.copy_(U.matmul(V.permute(0, 2, 1))) - - @staticmethod - def _matrix(self, params): - return tqf.qubitunitaryfast(params) - - -class TrainableUnitaryStrict(TrainableUnitary, metaclass=ABCMeta): - """Class for Strict Unitary matrix gate.""" - - num_params = AnyNParams - num_wires = AnyWires - func = staticmethod(tqf.qubitunitarystrict) - - -class CRX(Operation, metaclass=ABCMeta): - """Class for Controlled Rotation X gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.crx) - - @classmethod - def _matrix(cls, params): - return tqf.crx_matrix(params) - - -class CRY(Operation, metaclass=ABCMeta): - """Class for Controlled Rotation Y gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.cry) - - @classmethod - def _matrix(cls, params): - return tqf.cry_matrix(params) - - -class CRZ(Operation, metaclass=ABCMeta): - """Class for Controlled Rotation Z gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.crz) - - @classmethod - def _matrix(cls, params): - return tqf.crz_matrix(params) - - -class CRot(Operation, metaclass=ABCMeta): - """Class for Controlled Rotation gate.""" - - num_params = 3 - num_wires = 2 - func = staticmethod(tqf.crot) - - @classmethod - def _matrix(cls, params): - return tqf.crot_matrix(params) - - -class U1(DiagonalOperation, metaclass=ABCMeta): - """Class for Controlled Rotation Y gate. U1 is the same - as phaseshift. - """ - - num_params = 1 - num_wires = 1 - func = staticmethod(tqf.u1) - - @classmethod - def _matrix(cls, params): - return tqf.u1_matrix(params) - - -class CU(Operation, metaclass=ABCMeta): - """Class for Controlled U gate (4-parameter two-qubit gate).""" - - num_params = 4 - num_wires = 2 - func = staticmethod(tqf.cu) - - @classmethod - def _matrix(cls, params): - return tqf.cu_matrix(params) - - -class CU1(DiagonalOperation, metaclass=ABCMeta): - """Class for controlled U1 gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.cu1) - - @classmethod - def _matrix(cls, params): - return tqf.cu1_matrix(params) - - -class U2(Operation, metaclass=ABCMeta): - """Class for U2 gate.""" - - num_params = 2 - num_wires = 1 - func = staticmethod(tqf.u2) - - @classmethod - def _matrix(cls, params): - return tqf.u2_matrix(params) - - -class CU2(Operation, metaclass=ABCMeta): - """Class for controlled U2 gate.""" - - num_params = 2 - num_wires = 2 - func = staticmethod(tqf.cu2) - - @classmethod - def _matrix(cls, params): - return tqf.cu2_matrix(params) - - -class U3(Operation, metaclass=ABCMeta): - """Class for U3 gate.""" - - num_params = 3 - num_wires = 1 - func = staticmethod(tqf.u3) - - @classmethod - def _matrix(cls, params): - return tqf.u3_matrix(params) - - -class CU3(Operation, metaclass=ABCMeta): - """Class for Controlled U3 gate.""" - - num_params = 3 - num_wires = 2 - func = staticmethod(tqf.cu3) - - @classmethod - def _matrix(cls, params): - return tqf.cu3_matrix(params) - - -class QubitUnitary(Operation, metaclass=ABCMeta): - """Class for controlled Qubit Unitary gate.""" - - num_params = AnyNParams - num_wires = AnyWires - func = staticmethod(tqf.qubitunitary) - - @classmethod - def _matrix(cls, params): - return tqf.qubitunitary_matrix(params) - - def build_params(self, trainable): - return None - - def reset_params(self, init_params=None): - self.params = torch.tensor(init_params, dtype=C_DTYPE) - self.register_buffer(f"{self.name}_unitary", self.params) - - -class QubitUnitaryFast(Operation, metaclass=ABCMeta): - """Class for fast implementation of - controlled Qubit Unitary gate.""" - - num_params = AnyNParams - num_wires = AnyWires - func = staticmethod(tqf.qubitunitaryfast) - - def __init__( - self, - has_params: bool = False, - trainable: bool = False, - init_params=None, - n_wires=None, - wires=None, - ): - super().__init__( - has_params=True, - trainable=trainable, - init_params=init_params, - n_wires=n_wires, - wires=wires, - ) - - @classmethod - def from_controlled_operation( - cls, - op, - c_wires, - t_wires, - trainable, - ): - """ - - Args: - op: the operation - c_wires: controlled wires, will only be a set such as 1, [2,3] - t_wires: can be a list of list of wires, multiple sets - [[1,2], [3,4]] - trainable: - """ - op = op - c_wires = np.array(c_wires) - t_wires = np.array(t_wires) - trainable = trainable - # self.n_t_wires = op.n_wires - # assert len(t_wires) == op.n_wires - - orig_u = op.matrix - orig_u_n_wires = op.n_wires - - wires = [] - - if c_wires.ndim == 0: - # only one control qubit - # 1 - n_c_wires = 1 - wires.append(c_wires.item()) - elif c_wires.ndim == 1: - # multiple control qubits - # [1, 2] - n_c_wires = c_wires.shape[0] - wires.extend(list(c_wires)) - - if t_wires.ndim == 0: - # single qubit U on one set - # 2 - n_t_wires = 1 - n_set_t_wires = 1 - wires.append(t_wires.item()) - elif t_wires.ndim == 1: - # single qubit U on multiple sets - # [1, 2, 3] - # or multi qubit U on one set - # [2, 3] - n_t_wires = t_wires.shape[0] - n_set_t_wires = n_t_wires // orig_u_n_wires - wires.extend(list(t_wires.flatten())) - - elif t_wires.ndim == 2: - # multi qubit unitary on multiple sets - # [[2, 3], [4, 5]] - n_t_wires = t_wires.flatten().shape[0] - n_set_t_wires = n_t_wires // orig_u_n_wires - wires.extend(list(t_wires.flatten())) - - n_wires = n_c_wires + n_t_wires - - # compute the new unitary, then permute - unitary = torch.tensor(torch.zeros(2**n_wires, 2**n_wires, dtype=C_DTYPE)) - for k in range(2**n_wires - 2**n_t_wires): - unitary[k, k] = 1.0 + 0.0j - - # compute kronecker product of all the controlled target - - controlled_u = None - for k in range(n_set_t_wires): - if controlled_u is None: - controlled_u = orig_u - else: - controlled_u = torch.kron(controlled_u, orig_u) - - d_controlled_u = controlled_u.shape[-1] - unitary[-d_controlled_u:, -d_controlled_u:] = controlled_u - - return cls( - has_params=True, - trainable=trainable, - init_params=unitary, - n_wires=n_wires, - wires=wires, - ) - - @classmethod - def _matrix(cls, params): - return tqf.qubitunitaryfast_matrix(params) - - def build_params(self, trainable): - return None - - def reset_params(self, init_params=None): - self.params = torch.tensor(init_params, dtype=C_DTYPE) - self.register_buffer(f"{self.name}_unitary", self.params) - - -class MultiCNOT(Operation, metaclass=ABCMeta): - """Class for Multi qubit CNOT gate.""" - - num_params = 0 - num_wires = AnyWires - func = staticmethod(tqf.multicnot) - - @classmethod - def _matrix(cls, params, n_wires): - return tqf.multicnot_matrix(n_wires) - - @property - def matrix(self): - op_matrix = self._matrix(self.params, self.n_wires) - return op_matrix - - -class MultiXCNOT(Operation, metaclass=ABCMeta): - """Class for Multi qubit XCNOT gate.""" - - num_params = 0 - num_wires = AnyWires - func = staticmethod(tqf.multixcnot) - - @classmethod - def _matrix(cls, params, n_wires): - return tqf.multixcnot_matrix(n_wires) - - @property - def matrix(self): - op_matrix = self._matrix(self.params, self.n_wires) - return op_matrix - - -class Reset(Operator, metaclass=ABCMeta): - """Class for Reset gate.""" - - num_params = 0 - num_wires = AnyWires - func = staticmethod(tqf.reset) - - @classmethod - def _matrix(cls, params): - return None - - -class SingleExcitation(Operator, metaclass=ABCMeta): - """Class for SingleExcitation gate.""" - - num_params = 1 - num_wires = 2 - func = staticmethod(tqf.singleexcitation) - - @classmethod - def _matrix(cls, params): - return tqf.singleexcitation_matrix(params) - - -class ECR(Operation, metaclass=ABCMeta): - """Class for Echoed Cross Resonance Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["ecr"] - func = staticmethod(tqf.ecr) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class QFT(Observable, metaclass=ABCMeta): - """Class for Quantum Fourier Transform.""" - - num_params = 0 - num_wires = AnyWires - func = staticmethod(tqf.qft) - - @classmethod - def _matrix(cls, params, n_wires): - return tqf.qft_matrix(n_wires) - - -class SDG(Operation, metaclass=ABCMeta): - """Class for SDG Gate.""" - - num_params = 0 - num_wires = 1 - - matrix = mat_dict["sdg"] - func = staticmethod(tqf.sdg) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class TDG(Operation, metaclass=ABCMeta): - """Class for TDG Gate.""" - - num_params = 0 - num_wires = 1 - matrix = mat_dict["tdg"] - func = staticmethod(tqf.tdg) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class SXDG(Operation, metaclass=ABCMeta): - """Class for SXDG Gate.""" - - num_params = 0 - num_wires = 1 - matrix = mat_dict["sxdg"] - func = staticmethod(tqf.sxdg) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class CCZ(Operation, metaclass=ABCMeta): - """Class for CCZ Gate.""" - - num_params = 0 - num_wires = 3 - matrix = mat_dict["ccz"] - func = staticmethod(tqf.ccz) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class ISWAP(Operation, metaclass=ABCMeta): - """Class for ISWAP Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["iswap"] - func = staticmethod(tqf.iswap) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class CS(Operation, metaclass=ABCMeta): - """Class for CS Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["cs"] - eigvals = np.array([1, 1, 1, 1j]) - func = staticmethod(tqf.cs) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - -class CSDG(DiagonalOperation, metaclass=ABCMeta): - """Class for CS Dagger Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["csdg"] - eigvals = np.array([1, 1, 1, -1j]) - func = staticmethod(tqf.csdg) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - -class CSX(Operation, metaclass=ABCMeta): - """Class for CSX Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["csx"] - func = staticmethod(tqf.csx) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class CHadamard(Operation, metaclass=ABCMeta): - """Class for CHadamard Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["chadamard"] - func = staticmethod(tqf.chadamard) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class CCZ(DiagonalOperation, metaclass=ABCMeta): - """Class for CCZ Gate.""" - - num_params = 0 - num_wires = 3 - matrix = mat_dict["ccz"] - eigvals = np.array([1, 1, 1, 1, 1, 1, 1, -1]) - func = staticmethod(tqf.ccz) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - @classmethod - def _eigvals(cls, params): - return cls.eigvals - - -class DCX(Operation, metaclass=ABCMeta): - """Class for DCX Gate.""" - - num_params = 0 - num_wires = 2 - matrix = mat_dict["dcx"] - func = staticmethod(tqf.dcx) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class XXMINYY(Operation, metaclass=ABCMeta): - """Class for XXMinusYY gate.""" - - num_params = 2 - num_wires = 2 - func = staticmethod(tqf.xxminyy_matrix) - - @classmethod - def _matrix(cls, params): - return tqf.xxminyy_matrix(params) - - -class XXPLUSYY(Operation, metaclass=ABCMeta): - """Class for XXPlusYY gate.""" - - num_params = 2 - num_wires = 2 - func = staticmethod(tqf.xxplusyy_matrix) - - @classmethod - def _matrix(cls, params): - return tqf.xxplusyy_matrix(params) - - -class C3X(Operation, metaclass=ABCMeta): - """Class for C3X gate.""" - - num_params = 0 - num_wires = 4 - matrix = mat_dict["c3x"] - func = staticmethod(tqf.c3x) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class R(DiagonalOperation, metaclass=ABCMeta): - """Class for R Gate.""" - - num_params = 2 - num_wires = 1 - func = staticmethod(tqf.r) - - @classmethod - def _matrix(cls, params): - return tqf.r_matrix(params) - - -class C4X(Operation, metaclass=ABCMeta): - """Class for C4X Gate.""" - - num_params = 0 - num_wires = 5 - matrix = mat_dict["c4x"] - func = staticmethod(tqf.c4x) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class RC3X(Operation, metaclass=ABCMeta): - """Class for RC3X Gate.""" - - num_params = 0 - num_wires = 4 - matrix = mat_dict["rc3x"] - func = staticmethod(tqf.rc3x) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class RCCX(Operation, metaclass=ABCMeta): - """Class for RCCX Gate.""" - - num_params = 0 - num_wires = 3 - matrix = mat_dict["rccx"] - func = staticmethod(tqf.rccx) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -class GlobalPhase(Operation, metaclass=ABCMeta): - """Class for Global Phase gate.""" - - num_params = 1 - num_wires = 0 - func = staticmethod(tqf.globalphase) - - @classmethod - def _matrix(cls, params): - return tqf.globalphase_matrix(params) - - -class C3SX(Operation, metaclass=ABCMeta): - """Class for C3SX Gate.""" - - num_params = 0 - num_wires = 4 - matrix = mat_dict["c3sx"] - func = staticmethod(tqf.c3sx) - - @classmethod - def _matrix(cls, params): - return cls.matrix - - -H = Hadamard -SH = SHadamard -EchoedCrossResonance = ECR -CH = CHadamard - op_name_dict = { "hadamard": Hadamard, "h": Hadamard, diff --git a/torchquantum/operator/paulix.py b/torchquantum/operator/paulix.py index 92b98911..c709196b 100644 --- a/torchquantum/operator/paulix.py +++ b/torchquantum/operator/paulix.py @@ -1,4 +1,4 @@ -from .op_types import Observable +from .op_types import * from abc import ABCMeta from ..macro import C_DTYPE import torchquantum as tq @@ -26,3 +26,89 @@ def _eigvals(cls, params): def diagonalizing_gates(self): return [tq.Hadamard()] + + +class CNOT(Operation, metaclass=ABCMeta): + """Class for CNOT Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["cnot"] + func = staticmethod(tqf.cnot) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class C4X(Operation, metaclass=ABCMeta): + """Class for C4X Gate.""" + + num_params = 0 + num_wires = 5 + matrix = mat_dict["c4x"] + func = staticmethod(tqf.c4x) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class C3X(Operation, metaclass=ABCMeta): + """Class for C3X gate.""" + + num_params = 0 + num_wires = 4 + matrix = mat_dict["c3x"] + func = staticmethod(tqf.c3x) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class DCX(Operation, metaclass=ABCMeta): + """Class for DCX Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["dcx"] + func = staticmethod(tqf.dcx) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class MultiCNOT(Operation, metaclass=ABCMeta): + """Class for Multi qubit CNOT gate.""" + + num_params = 0 + num_wires = AnyWires + func = staticmethod(tqf.multicnot) + + @classmethod + def _matrix(cls, params, n_wires): + return tqf.multicnot_matrix(n_wires) + + @property + def matrix(self): + op_matrix = self._matrix(self.params, self.n_wires) + return op_matrix + + +class MultiXCNOT(Operation, metaclass=ABCMeta): + """Class for Multi qubit XCNOT gate.""" + + num_params = 0 + num_wires = AnyWires + func = staticmethod(tqf.multixcnot) + + @classmethod + def _matrix(cls, params, n_wires): + return tqf.multixcnot_matrix(n_wires) + + @property + def matrix(self): + op_matrix = self._matrix(self.params, self.n_wires) + return op_matrix diff --git a/torchquantum/operator/pauliy.py b/torchquantum/operator/pauliy.py index 36569640..3cbee0cc 100644 --- a/torchquantum/operator/pauliy.py +++ b/torchquantum/operator/pauliy.py @@ -1,4 +1,4 @@ -from .op_types import Observable +from .op_types import Observable, Operation from abc import ABCMeta from ..macro import C_DTYPE import torchquantum as tq @@ -26,3 +26,16 @@ def _eigvals(cls, params): def diagonalizing_gates(self): return [tq.PauliZ(), tq.S(), tq.Hadamard()] + + +class CY(Operation, metaclass=ABCMeta): + """Class for CY Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["cy"] + func = staticmethod(tqf.cy) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/pauliz.py b/torchquantum/operator/pauliz.py index d314afd2..b8b7f074 100644 --- a/torchquantum/operator/pauliz.py +++ b/torchquantum/operator/pauliz.py @@ -1,4 +1,4 @@ -from .op_types import Observable +from .op_types import Observable, DiagonalOperation from abc import ABCMeta from ..macro import C_DTYPE import torchquantum as tq @@ -26,3 +26,39 @@ def _eigvals(cls, params): def diagonalizing_gates(self): return [] + + +class CZ(DiagonalOperation, metaclass=ABCMeta): + """Class for CZ Gate.""" + + num_params = 0 + num_wires = 2 + eigvals = torch.tensor([1, 1, 1, -1], dtype=C_DTYPE) + matrix = mat_dict["cz"] + func = staticmethod(tqf.cz) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + +class CCZ(DiagonalOperation, metaclass=ABCMeta): + """Class for CCZ Gate.""" + + num_params = 0 + num_wires = 3 + matrix = mat_dict["ccz"] + eigvals = torch.tensor([1, 1, 1, 1, 1, 1, 1, -1], dtype=C_DTYPE) + func = staticmethod(tqf.ccz) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals diff --git a/torchquantum/operator/phase_shift.py b/torchquantum/operator/phase_shift.py new file mode 100644 index 00000000..a908490c --- /dev/null +++ b/torchquantum/operator/phase_shift.py @@ -0,0 +1,19 @@ +from .op_types import DiagonalOperation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class PhaseShift(DiagonalOperation, metaclass=ABCMeta): + """Class for PhaseShift Gate.""" + + num_params = 1 + num_wires = 1 + func = staticmethod(tqf.phaseshift) + + @classmethod + def _matrix(cls, params): + return tqf.phaseshift_matrix(params) diff --git a/torchquantum/operator/qft.py b/torchquantum/operator/qft.py new file mode 100644 index 00000000..0e1d192d --- /dev/null +++ b/torchquantum/operator/qft.py @@ -0,0 +1,19 @@ +from .op_types import Observable, AnyWires +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class QFT(Observable, metaclass=ABCMeta): + """Class for Quantum Fourier Transform.""" + + num_params = 0 + num_wires = AnyWires + func = staticmethod(tqf.qft) + + @classmethod + def _matrix(cls, params, n_wires): + return tqf.qft_matrix(n_wires) diff --git a/torchquantum/operator/qubit_unitary.py b/torchquantum/operator/qubit_unitary.py new file mode 100644 index 00000000..0e8750d4 --- /dev/null +++ b/torchquantum/operator/qubit_unitary.py @@ -0,0 +1,151 @@ +from .op_types import * +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class QubitUnitary(Operation, metaclass=ABCMeta): + """Class for controlled Qubit Unitary gate.""" + + num_params = AnyNParams + num_wires = AnyWires + func = staticmethod(tqf.qubitunitary) + + @classmethod + def _matrix(cls, params): + return tqf.qubitunitary_matrix(params) + + def build_params(self, trainable): + return None + + def reset_params(self, init_params=None): + self.params = torch.tensor(init_params, dtype=C_DTYPE) + self.register_buffer(f"{self.name}_unitary", self.params) + + +class QubitUnitaryFast(Operation, metaclass=ABCMeta): + """Class for fast implementation of + controlled Qubit Unitary gate.""" + + num_params = AnyNParams + num_wires = AnyWires + func = staticmethod(tqf.qubitunitaryfast) + + def __init__( + self, + has_params: bool = False, + trainable: bool = False, + init_params=None, + n_wires=None, + wires=None, + ): + super().__init__( + has_params=True, + trainable=trainable, + init_params=init_params, + n_wires=n_wires, + wires=wires, + ) + + @classmethod + def from_controlled_operation( + cls, + op, + c_wires, + t_wires, + trainable, + ): + """ + + Args: + op: the operation + c_wires: controlled wires, will only be a set such as 1, [2,3] + t_wires: can be a list of list of wires, multiple sets + [[1,2], [3,4]] + trainable: + """ + op = op + c_wires = np.array(c_wires) + t_wires = np.array(t_wires) + trainable = trainable + # self.n_t_wires = op.n_wires + # assert len(t_wires) == op.n_wires + + orig_u = op.matrix + orig_u_n_wires = op.n_wires + + wires = [] + + if c_wires.ndim == 0: + # only one control qubit + # 1 + n_c_wires = 1 + wires.append(c_wires.item()) + elif c_wires.ndim == 1: + # multiple control qubits + # [1, 2] + n_c_wires = c_wires.shape[0] + wires.extend(list(c_wires)) + + if t_wires.ndim == 0: + # single qubit U on one set + # 2 + n_t_wires = 1 + n_set_t_wires = 1 + wires.append(t_wires.item()) + elif t_wires.ndim == 1: + # single qubit U on multiple sets + # [1, 2, 3] + # or multi qubit U on one set + # [2, 3] + n_t_wires = t_wires.shape[0] + n_set_t_wires = n_t_wires // orig_u_n_wires + wires.extend(list(t_wires.flatten())) + + elif t_wires.ndim == 2: + # multi qubit unitary on multiple sets + # [[2, 3], [4, 5]] + n_t_wires = t_wires.flatten().shape[0] + n_set_t_wires = n_t_wires // orig_u_n_wires + wires.extend(list(t_wires.flatten())) + + n_wires = n_c_wires + n_t_wires + + # compute the new unitary, then permute + unitary = torch.tensor(torch.zeros(2**n_wires, 2**n_wires, dtype=C_DTYPE)) + for k in range(2**n_wires - 2**n_t_wires): + unitary[k, k] = 1.0 + 0.0j + + # compute kronecker product of all the controlled target + + controlled_u = None + for k in range(n_set_t_wires): + if controlled_u is None: + controlled_u = orig_u + else: + controlled_u = torch.kron(controlled_u, orig_u) + + d_controlled_u = controlled_u.shape[-1] + unitary[-d_controlled_u:, -d_controlled_u:] = controlled_u + + return cls( + has_params=True, + trainable=trainable, + init_params=unitary, + n_wires=n_wires, + wires=wires, + ) + + @classmethod + def _matrix(cls, params): + return tqf.qubitunitaryfast_matrix(params) + + def build_params(self, trainable): + return None + + def reset_params(self, init_params=None): + self.params = torch.tensor(init_params, dtype=C_DTYPE) + self.register_buffer(f"{self.name}_unitary", self.params) diff --git a/torchquantum/operator/r.py b/torchquantum/operator/r.py new file mode 100644 index 00000000..76caf426 --- /dev/null +++ b/torchquantum/operator/r.py @@ -0,0 +1,19 @@ +from .op_types import DiagonalOperation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class R(DiagonalOperation, metaclass=ABCMeta): + """Class for R Gate.""" + + num_params = 2 + num_wires = 1 + func = staticmethod(tqf.r) + + @classmethod + def _matrix(cls, params): + return tqf.r_matrix(params) diff --git a/torchquantum/operator/reset.py b/torchquantum/operator/reset.py new file mode 100644 index 00000000..640093cb --- /dev/null +++ b/torchquantum/operator/reset.py @@ -0,0 +1,19 @@ +from .op_types import Operator, AnyWires +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class Reset(Operator, metaclass=ABCMeta): + """Class for Reset gate.""" + + num_params = 0 + num_wires = AnyWires + func = staticmethod(tqf.reset) + + @classmethod + def _matrix(cls, params): + return None diff --git a/torchquantum/operator/rot.py b/torchquantum/operator/rot.py new file mode 100644 index 00000000..fec3d040 --- /dev/null +++ b/torchquantum/operator/rot.py @@ -0,0 +1,31 @@ +from .op_types import Observable, Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class Rot(Operation, metaclass=ABCMeta): + """Class for Rotation Gate.""" + + num_params = 3 + num_wires = 1 + func = staticmethod(tqf.rot) + + @classmethod + def _matrix(cls, params): + return tqf.rot_matrix(params) + + +class CRot(Operation, metaclass=ABCMeta): + """Class for Controlled Rotation gate.""" + + num_params = 3 + num_wires = 2 + func = staticmethod(tqf.crot) + + @classmethod + def _matrix(cls, params): + return tqf.crot_matrix(params) diff --git a/torchquantum/operator/rx.py b/torchquantum/operator/rx.py new file mode 100644 index 00000000..8773d765 --- /dev/null +++ b/torchquantum/operator/rx.py @@ -0,0 +1,43 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class RX(Operation, metaclass=ABCMeta): + """Class for RX Gate.""" + + num_params = 1 + num_wires = 1 + func = staticmethod(tqf.rx) + + @classmethod + def _matrix(cls, params): + return tqf.rx_matrix(params) + + +class RXX(Operation, metaclass=ABCMeta): + """Class for RXX Gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.rxx) + + @classmethod + def _matrix(cls, params): + return tqf.rxx_matrix(params) + + +class CRX(Operation, metaclass=ABCMeta): + """Class for Controlled Rotation X gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.crx) + + @classmethod + def _matrix(cls, params): + return tqf.crx_matrix(params) diff --git a/torchquantum/operator/ry.py b/torchquantum/operator/ry.py new file mode 100644 index 00000000..cf4fdedc --- /dev/null +++ b/torchquantum/operator/ry.py @@ -0,0 +1,43 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class RY(Operation, metaclass=ABCMeta): + """Class for RY Gate.""" + + num_params = 1 + num_wires = 1 + func = staticmethod(tqf.ry) + + @classmethod + def _matrix(cls, params): + return tqf.ry_matrix(params) + + +class RYY(Operation, metaclass=ABCMeta): + """Class for RYY Gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.ryy) + + @classmethod + def _matrix(cls, params): + return tqf.ryy_matrix(params) + + +class CRY(Operation, metaclass=ABCMeta): + """Class for Controlled Rotation Y gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.cry) + + @classmethod + def _matrix(cls, params): + return tqf.cry_matrix(params) diff --git a/torchquantum/operator/rz.py b/torchquantum/operator/rz.py new file mode 100644 index 00000000..16d07d21 --- /dev/null +++ b/torchquantum/operator/rz.py @@ -0,0 +1,67 @@ +from .op_types import * +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class RZ(DiagonalOperation, metaclass=ABCMeta): + """Class for RZ Gate.""" + + num_params = 1 + num_wires = 1 + func = staticmethod(tqf.rz) + + @classmethod + def _matrix(cls, params): + return tqf.rz_matrix(params) + + +class MultiRZ(DiagonalOperation, metaclass=ABCMeta): + """Class for Multi-qubit RZ Gate.""" + + num_params = 1 + num_wires = AnyWires + func = staticmethod(tqf.multirz) + + @classmethod + def _matrix(cls, params, n_wires): + return tqf.multirz_matrix(params, n_wires) + + +class RZZ(DiagonalOperation, metaclass=ABCMeta): + """Class for RZZ Gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.rzz) + + @classmethod + def _matrix(cls, params): + return tqf.rzz_matrix(params) + + +class RZX(Operation, metaclass=ABCMeta): + """Class for RZX Gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.rzx) + + @classmethod + def _matrix(cls, params): + return tqf.rzx_matrix(params) + + +class CRZ(Operation, metaclass=ABCMeta): + """Class for Controlled Rotation Z gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.crz) + + @classmethod + def _matrix(cls, params): + return tqf.crz_matrix(params) diff --git a/torchquantum/operator/s.py b/torchquantum/operator/s.py index 9189f544..3ab1af93 100644 --- a/torchquantum/operator/s.py +++ b/torchquantum/operator/s.py @@ -1,4 +1,4 @@ -from .op_types import DiagonalOperation +from .op_types import DiagonalOperation, Operation from abc import ABCMeta from ..macro import C_DTYPE import torchquantum as tq @@ -23,3 +23,53 @@ def _matrix(cls, params): @classmethod def _eigvals(cls, params): return cls.eigvals + + +class SDG(Operation, metaclass=ABCMeta): + """Class for SDG Gate.""" + + num_params = 0 + num_wires = 1 + + matrix = mat_dict["sdg"] + func = staticmethod(tqf.sdg) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class CS(Operation, metaclass=ABCMeta): + """Class for CS Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["cs"] + eigvals = torch.tensor([1, 1, 1, 1j], dtype=C_DTYPE) + func = staticmethod(tqf.cs) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals + + +class CSDG(DiagonalOperation, metaclass=ABCMeta): + """Class for CS Dagger Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["csdg"] + eigvals = torch.tensor([1, 1, 1, -1j], dtype=C_DTYPE) + func = staticmethod(tqf.csdg) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + @classmethod + def _eigvals(cls, params): + return cls.eigvals diff --git a/torchquantum/operator/single_excitation.py b/torchquantum/operator/single_excitation.py new file mode 100644 index 00000000..62e2f18c --- /dev/null +++ b/torchquantum/operator/single_excitation.py @@ -0,0 +1,19 @@ +from .op_types import Operator +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class SingleExcitation(Operator, metaclass=ABCMeta): + """Class for SingleExcitation gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.singleexcitation) + + @classmethod + def _matrix(cls, params): + return tqf.singleexcitation_matrix(params) diff --git a/torchquantum/operator/swap.py b/torchquantum/operator/swap.py new file mode 100644 index 00000000..e3c63e45 --- /dev/null +++ b/torchquantum/operator/swap.py @@ -0,0 +1,46 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class SWAP(Operation, metaclass=ABCMeta): + """Class for SWAP Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["swap"] + func = staticmethod(tqf.swap) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class SSWAP(Operation, metaclass=ABCMeta): + """Class for SSWAP Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["sswap"] + func = staticmethod(tqf.sswap) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class CSWAP(Operation, metaclass=ABCMeta): + """Class for CSWAP Gate.""" + + num_params = 0 + num_wires = 3 + matrix = mat_dict["cswap"] + func = staticmethod(tqf.cswap) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/sx.py b/torchquantum/operator/sx.py index d91a6d71..a367c844 100644 --- a/torchquantum/operator/sx.py +++ b/torchquantum/operator/sx.py @@ -23,3 +23,42 @@ def _matrix(cls, params): @classmethod def _eigvals(cls, params): return cls.eigvals + + +class CSX(Operation, metaclass=ABCMeta): + """Class for CSX Gate.""" + + num_params = 0 + num_wires = 2 + matrix = mat_dict["csx"] + func = staticmethod(tqf.csx) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class C3SX(Operation, metaclass=ABCMeta): + """Class for C3SX Gate.""" + + num_params = 0 + num_wires = 4 + matrix = mat_dict["c3sx"] + func = staticmethod(tqf.c3sx) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class SXDG(Operation, metaclass=ABCMeta): + """Class for SXDG Gate.""" + + num_params = 0 + num_wires = 1 + matrix = mat_dict["sxdg"] + func = staticmethod(tqf.sxdg) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/t.py b/torchquantum/operator/t.py index 01634eb6..920617dc 100644 --- a/torchquantum/operator/t.py +++ b/torchquantum/operator/t.py @@ -1,4 +1,4 @@ -from .op_types import DiagonalOperation +from .op_types import DiagonalOperation, Operation from abc import ABCMeta from ..macro import C_DTYPE import torchquantum as tq @@ -23,3 +23,16 @@ def _matrix(cls, params): @classmethod def _eigvals(cls, params): return cls.eigvals + + +class TDG(Operation, metaclass=ABCMeta): + """Class for TDG Gate.""" + + num_params = 0 + num_wires = 1 + matrix = mat_dict["tdg"] + func = staticmethod(tqf.tdg) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/toffoli.py b/torchquantum/operator/toffoli.py new file mode 100644 index 00000000..3ca42ed2 --- /dev/null +++ b/torchquantum/operator/toffoli.py @@ -0,0 +1,46 @@ +from .op_types import Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class Toffoli(Operation, metaclass=ABCMeta): + """Class for Toffoli Gate.""" + + num_params = 0 + num_wires = 3 + matrix = mat_dict["toffoli"] + func = staticmethod(tqf.toffoli) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class RC3X(Operation, metaclass=ABCMeta): + """Class for RC3X Gate.""" + + num_params = 0 + num_wires = 4 + matrix = mat_dict["rc3x"] + func = staticmethod(tqf.rc3x) + + @classmethod + def _matrix(cls, params): + return cls.matrix + + +class RCCX(Operation, metaclass=ABCMeta): + """Class for RCCX Gate.""" + + num_params = 0 + num_wires = 3 + matrix = mat_dict["rccx"] + func = staticmethod(tqf.rccx) + + @classmethod + def _matrix(cls, params): + return cls.matrix diff --git a/torchquantum/operator/trainable_unitary.py b/torchquantum/operator/trainable_unitary.py new file mode 100644 index 00000000..06d56131 --- /dev/null +++ b/torchquantum/operator/trainable_unitary.py @@ -0,0 +1,58 @@ +from .op_types import * +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class TrainableUnitary(Operation, metaclass=ABCMeta): + """Class for TrainableUnitary Gate.""" + + num_params = AnyNParams + num_wires = AnyWires + func = staticmethod(tqf.qubitunitaryfast) + + def build_params(self, trainable): + """Build the parameters for the gate. + + Args: + trainable (bool): Whether the parameters are trainble. + + Returns: + torch.Tensor: Parameters. + + """ + parameters = nn.Parameter( + torch.empty(1, 2**self.n_wires, 2**self.n_wires, dtype=C_DTYPE) + ) + parameters.requires_grad = True if trainable else False + # self.register_parameter(f"{self.name}_params", parameters) + return parameters + + def reset_params(self, init_params=None): + """Reset the parameters. + + Args: + init_params (torch.Tensor, optional): Initial parameters. + + Returns: + None. + + """ + mat = torch.randn((1, 2**self.n_wires, 2**self.n_wires), dtype=C_DTYPE) + U, Sigma, V = torch.svd(mat) + self.params.data.copy_(U.matmul(V.permute(0, 2, 1))) + + @staticmethod + def _matrix(self, params): + return tqf.qubitunitaryfast(params) + + +class TrainableUnitaryStrict(TrainableUnitary, metaclass=ABCMeta): + """Class for Strict Unitary matrix gate.""" + + num_params = AnyNParams + num_wires = AnyWires + func = staticmethod(tqf.qubitunitarystrict) diff --git a/torchquantum/operator/u.py b/torchquantum/operator/u.py new file mode 100644 index 00000000..09021161 --- /dev/null +++ b/torchquantum/operator/u.py @@ -0,0 +1,19 @@ +from .op_types import Observable, Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class CU(Operation, metaclass=ABCMeta): + """Class for Controlled U gate (4-parameter two-qubit gate).""" + + num_params = 4 + num_wires = 2 + func = staticmethod(tqf.cu) + + @classmethod + def _matrix(cls, params): + return tqf.cu_matrix(params) diff --git a/torchquantum/operator/u1.py b/torchquantum/operator/u1.py new file mode 100644 index 00000000..cecc00c7 --- /dev/null +++ b/torchquantum/operator/u1.py @@ -0,0 +1,33 @@ +from .op_types import Observable, DiagonalOperation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class U1(DiagonalOperation, metaclass=ABCMeta): + """Class for Controlled Rotation Y gate. U1 is the same + as phaseshift. + """ + + num_params = 1 + num_wires = 1 + func = staticmethod(tqf.u1) + + @classmethod + def _matrix(cls, params): + return tqf.u1_matrix(params) + + +class CU1(DiagonalOperation, metaclass=ABCMeta): + """Class for controlled U1 gate.""" + + num_params = 1 + num_wires = 2 + func = staticmethod(tqf.cu1) + + @classmethod + def _matrix(cls, params): + return tqf.cu1_matrix(params) diff --git a/torchquantum/operator/u2.py b/torchquantum/operator/u2.py new file mode 100644 index 00000000..ea2eb36f --- /dev/null +++ b/torchquantum/operator/u2.py @@ -0,0 +1,31 @@ +from .op_types import Observable, Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class U2(Operation, metaclass=ABCMeta): + """Class for U2 gate.""" + + num_params = 2 + num_wires = 1 + func = staticmethod(tqf.u2) + + @classmethod + def _matrix(cls, params): + return tqf.u2_matrix(params) + + +class CU2(Operation, metaclass=ABCMeta): + """Class for controlled U2 gate.""" + + num_params = 2 + num_wires = 2 + func = staticmethod(tqf.cu2) + + @classmethod + def _matrix(cls, params): + return tqf.cu2_matrix(params) diff --git a/torchquantum/operator/u3.py b/torchquantum/operator/u3.py new file mode 100644 index 00000000..c27ab6fe --- /dev/null +++ b/torchquantum/operator/u3.py @@ -0,0 +1,31 @@ +from .op_types import Observable, Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class U3(Operation, metaclass=ABCMeta): + """Class for U3 gate.""" + + num_params = 3 + num_wires = 1 + func = staticmethod(tqf.u3) + + @classmethod + def _matrix(cls, params): + return tqf.u3_matrix(params) + + +class CU3(Operation, metaclass=ABCMeta): + """Class for Controlled U3 gate.""" + + num_params = 3 + num_wires = 2 + func = staticmethod(tqf.cu3) + + @classmethod + def _matrix(cls, params): + return tqf.cu3_matrix(params) diff --git a/torchquantum/operator/xx_min_yy.py b/torchquantum/operator/xx_min_yy.py new file mode 100644 index 00000000..e9913406 --- /dev/null +++ b/torchquantum/operator/xx_min_yy.py @@ -0,0 +1,19 @@ +from .op_types import Observable, Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class XXMINYY(Operation, metaclass=ABCMeta): + """Class for XXMinusYY gate.""" + + num_params = 2 + num_wires = 2 + func = staticmethod(tqf.xxminyy_matrix) + + @classmethod + def _matrix(cls, params): + return tqf.xxminyy_matrix(params) diff --git a/torchquantum/operator/xx_plus_yy.py b/torchquantum/operator/xx_plus_yy.py new file mode 100644 index 00000000..61664a09 --- /dev/null +++ b/torchquantum/operator/xx_plus_yy.py @@ -0,0 +1,19 @@ +from .op_types import Observable, Operation +from abc import ABCMeta +from ..macro import C_DTYPE +import torchquantum as tq +import torch +from torchquantum.functional import mat_dict +import torchquantum.functional.functionals as tqf + + +class XXPLUSYY(Operation, metaclass=ABCMeta): + """Class for XXPlusYY gate.""" + + num_params = 2 + num_wires = 2 + func = staticmethod(tqf.xxplusyy_matrix) + + @classmethod + def _matrix(cls, params): + return tqf.xxplusyy_matrix(params) From 1551eeba26d0e99ad9acaf7245653f358088d051 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Wed, 30 Aug 2023 23:04:23 -0400 Subject: [PATCH 009/106] added u gate alias and merged u and u3 files --- test/operator/test_op.py | 1 + torchquantum/operator/operators.py | 2 +- torchquantum/operator/u.py | 19 ------------------- torchquantum/operator/u3.py | 15 +++++++++++++++ 4 files changed, 17 insertions(+), 20 deletions(-) delete mode 100644 torchquantum/operator/u.py diff --git a/test/operator/test_op.py b/test/operator/test_op.py index 519bb2ef..677cb3b2 100644 --- a/test/operator/test_op.py +++ b/test/operator/test_op.py @@ -69,6 +69,7 @@ {"qiskit": qiskit_gate.CRYGate, "tq": tq.CRY}, {"qiskit": qiskit_gate.CRZGate, "tq": tq.CRZ}, # {'qiskit': qiskit_gate.?, 'tq': tq.CRot}, + {"qiskit": qiskit_gate.UGate, "tq": tq.U}, {"qiskit": qiskit_gate.U1Gate, "tq": tq.U1}, {"qiskit": qiskit_gate.U2Gate, "tq": tq.U2}, {"qiskit": qiskit_gate.U3Gate, "tq": tq.U3}, diff --git a/torchquantum/operator/operators.py b/torchquantum/operator/operators.py index c74b7c79..8e7c9c35 100644 --- a/torchquantum/operator/operators.py +++ b/torchquantum/operator/operators.py @@ -63,7 +63,6 @@ from .xx_plus_yy import * from .reset import * from .qubit_unitary import * -from .u import * from .u1 import * from .u2 import * from .u3 import * @@ -106,6 +105,7 @@ "CRY", "CRZ", "CRot", + "U", "U1", "U2", "U3", diff --git a/torchquantum/operator/u.py b/torchquantum/operator/u.py deleted file mode 100644 index 09021161..00000000 --- a/torchquantum/operator/u.py +++ /dev/null @@ -1,19 +0,0 @@ -from .op_types import Observable, Operation -from abc import ABCMeta -from ..macro import C_DTYPE -import torchquantum as tq -import torch -from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf - - -class CU(Operation, metaclass=ABCMeta): - """Class for Controlled U gate (4-parameter two-qubit gate).""" - - num_params = 4 - num_wires = 2 - func = staticmethod(tqf.cu) - - @classmethod - def _matrix(cls, params): - return tqf.cu_matrix(params) diff --git a/torchquantum/operator/u3.py b/torchquantum/operator/u3.py index c27ab6fe..85f0d15e 100644 --- a/torchquantum/operator/u3.py +++ b/torchquantum/operator/u3.py @@ -29,3 +29,18 @@ class CU3(Operation, metaclass=ABCMeta): @classmethod def _matrix(cls, params): return tqf.cu3_matrix(params) + + +class CU(Operation, metaclass=ABCMeta): + """Class for Controlled U gate (4-parameter two-qubit gate).""" + + num_params = 4 + num_wires = 2 + func = staticmethod(tqf.cu) + + @classmethod + def _matrix(cls, params): + return tqf.cu_matrix(params) + + +U = U3 From fedd224dc6ba52752b8a972a5ccee8361547e55a Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Thu, 31 Aug 2023 14:08:20 -0400 Subject: [PATCH 010/106] adding automatic pytest checks adding automatic pytest runs add tests for all branches fix the workflow --- .github/workflows/functional_tests.yaml | 38 +++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 .github/workflows/functional_tests.yaml diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml new file mode 100644 index 00000000..55f18b18 --- /dev/null +++ b/.github/workflows/functional_tests.yaml @@ -0,0 +1,38 @@ +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python + +name: Python package + +on: + push: + pull_request: + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.9", "3.10", "3.11"] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install flake8 pytest + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Lint with flake8 + run: | + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics + - name: Test with pytest + run: | + pytest From 8db6addea57ec807fa49634d5f3e43c226e96962 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Thu, 31 Aug 2023 14:24:46 -0400 Subject: [PATCH 011/106] [minor] fix nonexistent variables --- torchquantum/density/density_func.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/torchquantum/density/density_func.py b/torchquantum/density/density_func.py index eae37063..efcea462 100644 --- a/torchquantum/density/density_func.py +++ b/torchquantum/density/density_func.py @@ -36,10 +36,9 @@ __all__ = [ "func_name_dict", "mat_dict", - "apply_unitary_einsum", - "apply_unitary_bmm", + "apply_unitary_density_einsum", + "apply_unitary_density_bmm", "hadamard", - "Dhadamard", "shadamard", "paulix", "pauliy", From 5084dcb4b1a69656c5ad0b7c7637b6f6e1ed52a5 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Thu, 31 Aug 2023 14:27:12 -0400 Subject: [PATCH 012/106] [minor] fix density_func indentation --- torchquantum/density/density_mat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchquantum/density/density_mat.py b/torchquantum/density/density_mat.py index b8147615..b7e42244 100644 --- a/torchquantum/density/density_mat.py +++ b/torchquantum/density/density_mat.py @@ -751,7 +751,7 @@ def sswap( inverse: bool = False, comp_method: str = "bmm", ): - """Apply a symmetric swap gate on the specified wires. + """Apply a symmetric swap gate on the specified wires. This method applies a symmetric swap gate on the specified wires of the quantum device. The gate is applied to all the wires if the inverse flag is set to False. From c0af684515af72d67f63df520b32ccbebb502e7f Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Thu, 31 Aug 2023 22:53:11 -0400 Subject: [PATCH 013/106] add dependencies to test and add skip marker added qiskit dependency take ii adding missing dependency rename faulty test added skip wrapper updated pytest to deselect tests undo rename manually --- .github/workflows/functional_tests.yaml | 6 +++--- test/hadamard_grad/test_hadamard_grad.py | 4 +++- test/plugin/test_qiskit_plugins.py | 3 ++- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 55f18b18..af549120 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -14,7 +14,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.9", "3.10", "3.11"] + python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] steps: - uses: actions/checkout@v3 @@ -25,7 +25,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install flake8 pytest + python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Lint with flake8 run: | @@ -35,4 +35,4 @@ jobs: flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | - pytest + pytest -m "not skip" diff --git a/test/hadamard_grad/test_hadamard_grad.py b/test/hadamard_grad/test_hadamard_grad.py index c6d3d7cd..21b5cc0f 100644 --- a/test/hadamard_grad/test_hadamard_grad.py +++ b/test/hadamard_grad/test_hadamard_grad.py @@ -1,7 +1,9 @@ import numpy as np from examples.hadamard_grad.circ import Circ1, Circ2, Circ3 from examples.hadamard_grad.hadamard_grad import hadamard_grad +import pytest +@pytest.mark.skip def test_hadamard_grad(): ''' We assume the circuits have unique and ordered parameters for now. @@ -36,4 +38,4 @@ def test_hadamard_grad(): if __name__ == "__main__": - test_hadamard_grad() \ No newline at end of file + test_hadamard_grad() diff --git a/test/plugin/test_qiskit_plugins.py b/test/plugin/test_qiskit_plugins.py index 4e4fdb28..b8e2cef7 100644 --- a/test/plugin/test_qiskit_plugins.py +++ b/test/plugin/test_qiskit_plugins.py @@ -33,6 +33,7 @@ from torchquantum.util import switch_little_big_endian_state import torch +import pytest pauli_str_op_dict = { "X": X, @@ -41,7 +42,7 @@ "I": I, } - +@pytest.mark.skip def test_expval_observable(): # seed = 0 # random.seed(seed) From 46c65bd38f809c3fcecfdafc923fa101fd1c426c Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Sat, 2 Sep 2023 15:48:40 -0400 Subject: [PATCH 014/106] [minor] update qiskit --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index f41cb0ef..9382f81b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,7 +8,7 @@ opt_einsum pathos>=0.2.7 pylatexenc>=2.10 pyscf>=2.0.1 -qiskit==0.38.0 +qiskit>=0.38.0 recommonmark scipy>=1.5.2 From ac868abb5c040a18cb300b0eb2c2e453f53ec600 Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Sat, 2 Sep 2023 16:21:30 -0400 Subject: [PATCH 015/106] [minor] update qiskit --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 9382f81b..88a06d50 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,7 +8,7 @@ opt_einsum pathos>=0.2.7 pylatexenc>=2.10 pyscf>=2.0.1 -qiskit>=0.38.0 +qiskit>=0.39.0 recommonmark scipy>=1.5.2 From 744b49a7d37f0cf5d34d28dedc0fdf824762dc6d Mon Sep 17 00:00:00 2001 From: Zhaoyilunnn Date: Tue, 12 Sep 2023 07:58:46 +0000 Subject: [PATCH 016/106] fix: make the parameter shift example compatible with latest torchquantum --- .../param_shift.py | 12 +- .../param_shift_onchip_training.ipynb | 10701 ++++++++-------- 2 files changed, 5596 insertions(+), 5117 deletions(-) diff --git a/examples/param_shift_onchip_training/param_shift.py b/examples/param_shift_onchip_training/param_shift.py index 7cd8981c..3f426fe8 100644 --- a/examples/param_shift_onchip_training/param_shift.py +++ b/examples/param_shift_onchip_training/param_shift.py @@ -29,7 +29,7 @@ import torchquantum as tq import torchquantum.functional as tqf -from torchquantum.layer import SethLayer0 +from torchquantum.layer.layers import SethLayer0 from torchquantum.dataset import MNIST from torch.optim.lr_scheduler import CosineAnnealingLR @@ -39,7 +39,6 @@ class QFCModel(tq.QuantumModule): def __init__(self): super().__init__() self.n_wires = 4 - self.q_device = tq.QuantumDevice(n_wires=self.n_wires) self.encoder = tq.GeneralEncoder(tq.encoder_op_list_name_dict["4x4_ryzxy"]) self.arch = {"n_wires": self.n_wires, "n_blocks": 2, "n_layers_per_block": 2} @@ -49,16 +48,17 @@ def __init__(self): def forward(self, x, use_qiskit=False): bsz = x.shape[0] + q_device = tq.QuantumDevice(n_wires=self.n_wires, bsz=bsz) x = F.avg_pool2d(x, 6).view(bsz, 16) if use_qiskit: x = self.qiskit_processor.process_parameterized( - self.q_device, self.encoder, self.q_layer, self.measure, x + q_device, self.encoder, self.q_layer, self.measure, x ) else: - self.encoder(self.q_device, x) - self.q_layer(self.q_device) - x = self.measure(self.q_device) + self.encoder(q_device, x) + self.q_layer(q_device) + x = self.measure(q_device) x = x.reshape(bsz, 4) diff --git a/examples/param_shift_onchip_training/param_shift_onchip_training.ipynb b/examples/param_shift_onchip_training/param_shift_onchip_training.ipynb index 8ddba030..0cb82c95 100644 --- a/examples/param_shift_onchip_training/param_shift_onchip_training.ipynb +++ b/examples/param_shift_onchip_training/param_shift_onchip_training.ipynb @@ -1,5195 +1,5674 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "flsf21MK3KTd" - }, - "source": [ - "# Apply parameters shift rules to train quantum model using [TorchQuantum](https://github.com/mit-han-lab/torchquantum).\n", - "

\n", - "\"torchquantum\n", - "

\n", - "\n", - "Tutorial Author: Zirui Li, Hanrui Wang\n" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "flsf21MK3KTd" + }, + "source": [ + "# Apply parameters shift rules to train quantum model using [TorchQuantum](https://github.com/mit-han-lab/torchquantum).\n", + "

\n", + "\"torchquantum\n", + "

\n", + "\n", + "Tutorial Author: Zirui Li, Hanrui Wang\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kvTdBipl6gqY" + }, + "source": [ + "###Outline\n", + "1. Introduction to Parameters Shift Rules.\n", + "2. Train a model with parameters shift rules.\n", + "3. A simple 2 qubit model for a simple 2 classification task.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qJv0wED75YTq" + }, + "source": [ + "\n", + "In this tutorial, you can learn parameters shift rules and how to use parameters shift rules to calculate gradients and use the gradient to train a model.\n", + "\n", + "##Introduction to Parameters Shift Rules\n", + "\n", + "###Back Propagation\n", + "\n", + "Previously, our quantum model was based on qiskit and pytorch. Once we did an inference of the model, pytorch will automatically build a computaional graph. We can calculate the gradients of each node in the computational graph in a reversed order based on the chain rule. This is called back propagation.\n", + "
\n", + "\"conv-full-layer\"\n", + "
\n", + "\n", + "###Parameters Shift Rules\n", + "\n", + "As we all know, when executing a quantum circuit on a real quantum machine, we can not observe the intermdiate quantum state. So, back propagation to calculate gradients are impossible when our circuits run on real quantum machines. Parameters shift rules offer us a technique to calculate gradients only by doing inference. For a circuit function $f(\\theta)$, we can calculate $f'(\\theta)$ by shifting $\\theta$ twice and minus one result by the other and multiply with a factor. The figure below describes the workflow of how to calculate the gradient of a parameter in a 4-qubit circuit.\n", + "\n", + "
\n", + "\"conv-full-layer\"\n", + "
\n", + "\n", + "Suppose an $m$-qubit quantum circuit is parametrized by $n$ parameters $\\theta=[\\theta_1,\\cdots,\\theta_i,\\cdots,\\theta_n]$, the expectation value of measures of this circuit can be represented by a circuit function,\n", + "$$f(\\theta)=\\langle\\psi|U(\\theta_i)^{\\dagger}\\widehat{Q}U(\\theta_i)|\\psi\\rangle, \\quad f(\\theta)\\in\\mathbb{R}^{m}, \\theta\\in\\mathbb{R}^n.\n", + "$$\n", + "where $\\theta_i$ is the scalar parameter whose gradient is to be calculated, and $U(\\theta_i)$ is the gate where $\\theta_i$ lies in. \n", + "\n", + "Here, for notation simplicity, we have already absorbed the unitaries before $U(\\theta_i)$ into $\\langle\\psi|$, $|\\psi\\rangle$.\n", + "Unitaries after $U(\\theta_i)$ and observables are fused into $\\widehat{Q}$.\n", + "\n", + "Usually, the rotation gates used in QNN can be written in the form $U(\\theta_i)=e^{-\\frac{i}{2}\\theta_i H}$. Here $H$ is the Hermitian generator of $U$ with only 2 unique eigenvalues +1 and -1.\n", + "\n", + "In this way, the gradients of the circuit function $f$ with respect to $\\theta_i$ are,\n", + "$$ \\begin{aligned}\n", + " &\\frac{\\partial f(\\theta)}{\\partial \\theta_i}=\\frac{1}{2}\\Big(f\\big(\\theta_+\\big)-f\\big(\\theta_{-}\\big)\\Big), \\\\ &\\theta_+=[\\theta_1,\\cdots,\\theta_i+\\frac{\\pi}{2},\\cdots,\\theta_n], \\theta_{-}=[\\theta_1,\\cdots,\\theta_i-\\frac{\\pi}{2},\\cdots,\\theta_n],\n", + " \\end{aligned}\n", + "$$\n", + "where $\\theta_+$ and $\\theta_{-}$ are the **positive shift** and **negative shift** of $\\theta$.\n", + "\n", + "Note that this parameter shift rule is **fundamentally different** from any numerical difference methods that only approximate the directional derivatives.\n", + "Instead, the equation calculates the **exact** gradient w.r.t $\\theta_i$ without any approximation errors or numerical issues. \n", + "\n", + "We apply $\\text{softmax}$ on $f(\\theta)$ as the predicted probability for each class. \n", + "Then we calculate the cross entropy between the predicted probability distribution $p$ and the target distribution $t$ as the classification loss $\\mathcal{L}$, \n", + "$$ \\mathcal{L}(\\theta)=-t^T\\cdot\\texttt{softmax}(f(\\theta))=-\\sum_{j=1}^m t_j \\log{p_j},\\quad p_j=\\frac{e^{f_j(\\theta)}}{\\sum_{j=1}^m e^{f_j(\\theta)}}.\n", + "$$\n", + "\n", + "Then the gradient of the loss function with respect to $\\theta_i$ is $\\frac{\\partial\\mathcal{L}(\\theta)}{\\partial \\theta_i}=\\big(\\frac{\\partial\\mathcal{L}(\\theta)}{\\partial f(\\theta)}\\big)^T\\frac{\\partial f(\\theta)}{\\partial \\theta_i}$.\n", + "\n", + "Here $\\frac{\\partial f(\\theta)}{\\partial \\theta_i}$ can be calculated on real quantum computer by the parameter shift rules, and $\\frac{\\partial\\mathcal{L}(\\theta)}{\\partial f(\\theta)}$ can be efficiently calculated on classical devices using backpropagation supported by automatic differentiation frameworks, e.g., PyTorch and TensorFlow.\n", + "\n", + "Now we derive the parameter shift rules used in our QNN models.\n", + "\n", + "Assume $U(\\theta_i)=R_X(\\theta_i),R_X(\\alpha)=e^{-\\frac{i}{2}\\alpha X}$, where $X$ is the Pauli-X matrix.\n", + "\n", + "Firstly, the RX gate is,\n", + "$$ \\begin{aligned}\n", + "R_X(\\alpha)&=e^{-\\frac{i}{2}\\alpha X}=\\sum_{k=0}^{\\infty}(-i\\alpha/2)^kX^k/k!\\\\\n", + "&=\\sum_{k=0}^{\\infty}(-i\\alpha/2)^{2k}X^{2k}/(2k)!+\\sum_{k=0}^{\\infty}(-i\\alpha/2)^{2k+1}X^{2k+1}/(2k+1)!\\\\\n", + "&=\\sum_{k=0}^{\\infty}(-1)^k(\\alpha/2)^{2k}I/(2k)!-i\\sum_{k=0}^{\\infty}(-1)^k(\\alpha/2)^{2k+1}X/(2k+1)!\\\\\n", + "&=\\cos(\\alpha/2)I-i\\sin(\\alpha/2)X.\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "Let $\\alpha=\\frac{\\pi}{2}$, $R_X(\\pm\\frac{\\pi}{2})=\\frac{1}{\\sqrt{2}}(I\\mp iX)$.\n", + "\n", + "As $f(\\theta)=\\langle\\psi|R_X(\\theta_i)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle$, $R_X(\\alpha)R_X(\\beta)=R_X(\\alpha+\\beta)$, and $\\frac{\\partial}{\\partial \\alpha}R_X(\\alpha)=-\\frac{i}{2}XR_X(\\alpha)$,\n", + "we have\n", + "$$\\begin{aligned}\n", + "\\frac{\\partial f(\\theta)}{\\partial \\theta_i}\n", + "% &=\\langle\\psi|\\frac{\\partial}{\\partial \\theta_i}R_X(\\theta_i)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle+\\langle\\psi|R_X(\\theta_i)^{\\dag}\\widehat{Q}\\frac{\\partial}{\\partial \\theta_i}R_X(\\theta_i)|\\psi\\rangle\\\\\n", + "=&\\langle\\psi|R_X(\\theta_i)^{\\dagger}(-\\frac{i}{2}X)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle+\\langle\\psi|R_X(\\theta_i)^{\\dagger}\\widehat{Q}(-\\frac{i}{2}X)R_X(\\theta_i)|\\psi\\rangle\\\\\n", + "% &=\\frac{1}{2}(\\langle\\psi|R_X(\\theta_i)^{\\dagger}(-iX)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle+\\langle\\psi|R_X(\\theta_i)^{\\dagger}\\widehat{Q}(-iX)R_X(\\theta_i)|\\psi\\rangle)\\\\\n", + "=&\\frac{1}{4}(\\langle\\psi|R_X(\\theta_i)^{\\dagger}(I-iX)^{\\dagger}\\widehat{Q}(I-iX)R_X(\\theta_i)|\\psi\\rangle\\\\&-\\langle\\psi|R_X(\\theta_i)^{\\dagger}(I+iX)^{\\dagger}\\widehat{Q}(I+iX)R_X(\\theta_i)|\\psi\\rangle)\\\\\n", + "=&\\frac{1}{2}(\\langle\\psi|R_X(\\theta_i)^{\\dagger}R_X(\\frac{\\pi}{2})^{\\dagger}\\widehat{Q}R_X(\\frac{\\pi}{2})R_X(\\theta_i)|\\psi\\rangle\\\\&-\\langle\\psi|R_X(\\theta_i)^{\\dagger}R_X(-\\frac{\\pi}{2})^{\\dagger}\\widehat{Q}R_X(-\\frac{\\pi}{2})R_X(\\theta_i)|\\psi\\rangle)\\\\\n", + "=&\\frac{1}{2}(f(\\theta_+)-f(\\theta_-)).\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "Without loss of generality, the derivation holds for all unitaries of the form $e^{-\\frac{i}{2}\\alpha H}$, e.g., RX, RY, RZ, XX, YY, ZZ, where $H$ is a Hermitian matrix with only 2 unique eigenvalues +1 and -1.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-42mdL8CG5Vi" + }, + "source": [ + "##Train a model with parameters shift rules" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pfwd2SNaOA4z" + }, + "source": [ + "###Installation\n", + "Firstly, install qiskit." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9ELpIlt-3HG8" + }, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "azb47tvSiaBp", + "outputId": "23c9c3f2-f8a5-45f6-d04d-811d798022e8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting qiskit==0.32.1\n", + " Downloading qiskit-0.32.1.tar.gz (13 kB)\n", + "Collecting qiskit-terra==0.18.3\n", + " Downloading qiskit_terra-0.18.3-cp37-cp37m-manylinux2010_x86_64.whl (6.1 MB)\n", + "\u001b[K |████████████████████████████████| 6.1 MB 7.5 MB/s \n", + "\u001b[?25hCollecting qiskit-aer==0.9.1\n", + " Downloading qiskit_aer-0.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (17.9 MB)\n", + "\u001b[K |████████████████████████████████| 17.9 MB 565 kB/s \n", + "\u001b[?25hCollecting qiskit-ibmq-provider==0.18.1\n", + " Downloading qiskit_ibmq_provider-0.18.1-py3-none-any.whl (237 kB)\n", + "\u001b[K |████████████████████████████████| 237 kB 47.9 MB/s \n", + "\u001b[?25hCollecting qiskit-ignis==0.6.0\n", + " Downloading qiskit_ignis-0.6.0-py3-none-any.whl (207 kB)\n", + "\u001b[K |████████████████████████████████| 207 kB 51.1 MB/s \n", + "\u001b[?25hCollecting qiskit-aqua==0.9.5\n", + " Downloading qiskit_aqua-0.9.5-py3-none-any.whl (2.1 MB)\n", + "\u001b[K |████████████████████████████████| 2.1 MB 40.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.9.1->qiskit==0.32.1) (1.21.5)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.9.1->qiskit==0.32.1) (1.4.1)\n", + "Collecting quandl\n", + " Downloading Quandl-3.7.0-py2.py3-none-any.whl (26 kB)\n", + "Requirement already satisfied: setuptools>=40.1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (57.4.0)\n", + "Requirement already satisfied: fastdtw<=0.3.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (0.3.4)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (1.7.1)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (1.3.5)\n", + "Requirement already satisfied: scikit-learn>=0.20.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (1.0.2)\n", + "Collecting docplex>=2.21.207\n", + " Downloading docplex-2.22.213.tar.gz (634 kB)\n", + "\u001b[K |████████████████████████████████| 634 kB 49.0 MB/s \n", + "\u001b[?25hCollecting dlx<=1.0.4\n", + " Downloading dlx-1.0.4.tar.gz (5.5 kB)\n", + "Collecting yfinance>=0.1.62\n", + " Downloading yfinance-0.1.70-py2.py3-none-any.whl (26 kB)\n", + "Requirement already satisfied: h5py<3.3.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (3.1.0)\n", + "Collecting retworkx>=0.8.0\n", + " Downloading retworkx-0.11.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.6 MB)\n", + "\u001b[K |████████████████████████████████| 1.6 MB 45.4 MB/s \n", + "\u001b[?25hRequirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (5.4.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.8.2)\n", + "Requirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (1.24.3)\n", + "Collecting websocket-client>=1.0.1\n", + " Downloading websocket_client-1.3.1-py3-none-any.whl (54 kB)\n", + "\u001b[K |████████████████████████████████| 54 kB 2.7 MB/s \n", + "\u001b[?25hRequirement already satisfied: requests>=2.19 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.23.0)\n", + "Collecting requests-ntlm>=1.1.0\n", + " Downloading requests_ntlm-1.1.0-py2.py3-none-any.whl (5.7 kB)\n", + "Collecting symengine>0.7\n", + " Downloading symengine-0.9.0-cp37-cp37m-manylinux2010_x86_64.whl (37.5 MB)\n", + "\u001b[K |████████████████████████████████| 37.5 MB 1.3 MB/s \n", + "\u001b[?25hCollecting fastjsonschema>=2.10\n", + " Downloading fastjsonschema-2.15.3-py3-none-any.whl (22 kB)\n", + "Collecting python-constraint>=1.4\n", + " Downloading python-constraint-1.4.0.tar.bz2 (18 kB)\n", + "Collecting ply>=3.10\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[K |████████████████████████████████| 49 kB 5.5 MB/s \n", + "\u001b[?25hRequirement already satisfied: jsonschema>=2.6 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit==0.32.1) (4.3.3)\n", + "Collecting tweedledum<2.0,>=1.1\n", + " Downloading tweedledum-1.1.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (943 kB)\n", + "\u001b[K |████████████████████████████████| 943 kB 43.9 MB/s \n", + "\u001b[?25hRequirement already satisfied: dill>=0.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit==0.32.1) (0.3.4)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from docplex>=2.21.207->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.15.0)\n", + "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py<3.3.0->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.5.2)\n", + "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (5.4.0)\n", + "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (0.18.1)\n", + "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (4.11.1)\n", + "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (21.4.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (3.10.0.2)\n", + "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from importlib-resources>=1.4.0->jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (3.7.0)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2021.10.8)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (3.0.4)\n", + "Collecting cryptography>=1.3\n", + " Downloading cryptography-36.0.1-cp36-abi3-manylinux_2_24_x86_64.whl (3.6 MB)\n", + "\u001b[K |████████████████████████████████| 3.6 MB 44.8 MB/s \n", + "\u001b[?25hCollecting ntlm-auth>=1.0.2\n", + " Downloading ntlm_auth-1.5.0-py2.py3-none-any.whl (29 kB)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (1.15.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.21)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit==0.32.1) (3.1.0)\n", + "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.1.0)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.7/dist-packages (from sympy>=1.3->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.2.1)\n", + "Collecting requests>=2.19\n", + " Downloading requests-2.27.1-py2.py3-none-any.whl (63 kB)\n", + "\u001b[K |████████████████████████████████| 63 kB 1.8 MB/s \n", + "\u001b[?25hRequirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.7/dist-packages (from yfinance>=0.1.62->qiskit-aqua==0.9.5->qiskit==0.32.1) (0.0.10)\n", + "Collecting lxml>=4.5.1\n", + " Downloading lxml-4.8.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl (6.4 MB)\n", + "\u001b[K |████████████████████████████████| 6.4 MB 20.2 MB/s \n", + "\u001b[?25hRequirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->qiskit-aqua==0.9.5->qiskit==0.32.1) (2018.9)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.0.12)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.7/dist-packages (from quandl->qiskit-aqua==0.9.5->qiskit==0.32.1) (8.12.0)\n", + "Collecting inflection>=0.3.1\n", + " Downloading inflection-0.5.1-py2.py3-none-any.whl (9.5 kB)\n", + "Building wheels for collected packages: qiskit, dlx, docplex, python-constraint\n", + " Building wheel for qiskit (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for qiskit: filename=qiskit-0.32.1-py3-none-any.whl size=11777 sha256=c8dd0aa33407d766de6e21a79c560a28d3aaed47ab5efde37ac60f61f0fc3275\n", + " Stored in directory: /root/.cache/pip/wheels/0f/62/0a/c53eda1ead41c137c47c9730bc2771a8367b1ce00fb64e8cc6\n", + " Building wheel for dlx (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for dlx: filename=dlx-1.0.4-py3-none-any.whl size=5718 sha256=88e879a69472bf6f871793f7a320337f70c30e734a308266be28dd0b5eb1d388\n", + " Stored in directory: /root/.cache/pip/wheels/78/55/c8/dc61e772445a566b7608a476d151e9dcaf4e092b01b0c4bc3c\n", + " Building wheel for docplex (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for docplex: filename=docplex-2.22.213-py3-none-any.whl size=696882 sha256=8a296841fded71c4005ec13d2237a5fcd0dc925f2debdbb6d9198745aa27fd30\n", + " Stored in directory: /root/.cache/pip/wheels/90/69/6b/1375c68a5b7ff94c40263b151c86f58bd72200bf0c465b5ba3\n", + " Building wheel for python-constraint (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for python-constraint: filename=python_constraint-1.4.0-py2.py3-none-any.whl size=24081 sha256=1e63dc909ecdff23baaaf9c6950a9f43558f4cbfddb001c3cb6eae6209ba594c\n", + " Stored in directory: /root/.cache/pip/wheels/07/27/db/1222c80eb1e431f3d2199c12569cb1cac60f562a451fe30479\n", + "Successfully built qiskit dlx docplex python-constraint\n", + "Installing collected packages: tweedledum, symengine, retworkx, python-constraint, ply, fastjsonschema, requests, qiskit-terra, ntlm-auth, lxml, inflection, cryptography, yfinance, websocket-client, requests-ntlm, quandl, qiskit-ignis, docplex, dlx, qiskit-ibmq-provider, qiskit-aqua, qiskit-aer, qiskit\n", + " Attempting uninstall: requests\n", + " Found existing installation: requests 2.23.0\n", + " Uninstalling requests-2.23.0:\n", + " Successfully uninstalled requests-2.23.0\n", + " Attempting uninstall: lxml\n", + " Found existing installation: lxml 4.2.6\n", + " Uninstalling lxml-4.2.6:\n", + " Successfully uninstalled lxml-4.2.6\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "google-colab 1.0.0 requires requests~=2.23.0, but you have requests 2.27.1 which is incompatible.\n", + "datascience 0.10.6 requires folium==0.2.1, but you have folium 0.8.3 which is incompatible.\u001b[0m\n", + "Successfully installed cryptography-36.0.1 dlx-1.0.4 docplex-2.22.213 fastjsonschema-2.15.3 inflection-0.5.1 lxml-4.8.0 ntlm-auth-1.5.0 ply-3.11 python-constraint-1.4.0 qiskit-0.32.1 qiskit-aer-0.9.1 qiskit-aqua-0.9.5 qiskit-ibmq-provider-0.18.1 qiskit-ignis-0.6.0 qiskit-terra-0.18.3 quandl-3.7.0 requests-2.27.1 requests-ntlm-1.1.0 retworkx-0.11.0 symengine-0.9.0 tweedledum-1.1.1 websocket-client-1.3.1 yfinance-0.1.70\n" + ] + } + ], + "source": [ + "!pip install qiskit==0.32.1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F2-0UpluOIQl" + }, + "source": [ + "Download and cd to the repo." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6sNqLl9tjjAf", + "outputId": "13bc623b-7e1f-4e26-bc94-b2f787bcb1d2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'torchquantum'...\n", + "remote: Enumerating objects: 10900, done.\u001b[K\n", + "remote: Counting objects: 100% (7692/7692), done.\u001b[K\n", + "remote: Compressing objects: 100% (3901/3901), done.\u001b[K\n", + "remote: Total 10900 (delta 3851), reused 7185 (delta 3382), pack-reused 3208\u001b[K\n", + "Receiving objects: 100% (10900/10900), 5.19 MiB | 16.99 MiB/s, done.\n", + "Resolving deltas: 100% (5818/5818), done.\n" + ] + } + ], + "source": [ + "!git clone https://github.com/mit-han-lab/torchquantum.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0c2MCqFXjxkD", + "outputId": "8c41b140-edeb-4bb0-b725-907e0f5b0f97" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/content/torchquantum\n" + ] + } + ], + "source": [ + "%cd torchquantum" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PO1xLbaOOxWk" + }, + "source": [ + "Install torch-quantum." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3c6nfq3KkVXG", + "outputId": "792edc41-4ca4-4ede-eed3-0cff8f56dc53" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Obtaining file:///content/torchquantum\n", + "Requirement already satisfied: numpy>=1.19.2 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (1.21.5)\n", + "Requirement already satisfied: torchvision>=0.9.0.dev20210130 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (0.11.1+cu111)\n", + "Requirement already satisfied: tqdm>=4.56.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (4.62.3)\n", + "Requirement already satisfied: setuptools>=52.0.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (57.4.0)\n", + "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (1.10.0+cu111)\n", + "Collecting torchpack>=0.3.0\n", + " Downloading torchpack-0.3.1-py3-none-any.whl (34 kB)\n", + "Requirement already satisfied: qiskit>=0.32.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (0.32.1)\n", + "Collecting matplotlib>=3.3.2\n", + " Downloading matplotlib-3.5.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (11.2 MB)\n", + "\u001b[K |████████████████████████████████| 11.2 MB 12.1 MB/s \n", + "\u001b[?25hCollecting pathos>=0.2.7\n", + " Downloading pathos-0.2.8-py2.py3-none-any.whl (81 kB)\n", + "\u001b[K |████████████████████████████████| 81 kB 10.9 MB/s \n", + "\u001b[?25hCollecting fonttools>=4.22.0\n", + " Downloading fonttools-4.29.1-py3-none-any.whl (895 kB)\n", + "\u001b[K |████████████████████████████████| 895 kB 45.1 MB/s \n", + "\u001b[?25hRequirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (1.3.2)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (3.0.7)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (0.11.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (21.3)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (7.1.2)\n", + "Requirement already satisfied: multiprocess>=0.70.12 in /usr/local/lib/python3.7/dist-packages (from pathos>=0.2.7->torchquantum==0.1.0) (0.70.12.2)\n", + "Collecting ppft>=1.6.6.4\n", + " Downloading ppft-1.6.6.4-py3-none-any.whl (65 kB)\n", + "\u001b[K |████████████████████████████████| 65 kB 3.5 MB/s \n", + "\u001b[?25hCollecting pox>=0.3.0\n", + " Downloading pox-0.3.0-py2.py3-none-any.whl (30 kB)\n", + "Requirement already satisfied: dill>=0.3.4 in /usr/local/lib/python3.7/dist-packages (from pathos>=0.2.7->torchquantum==0.1.0) (0.3.4)\n", + "Requirement already satisfied: six>=1.7.3 in /usr/local/lib/python3.7/dist-packages (from ppft>=1.6.6.4->pathos>=0.2.7->torchquantum==0.1.0) (1.15.0)\n", + "Requirement already satisfied: qiskit-ibmq-provider==0.18.1 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.18.1)\n", + "Requirement already satisfied: qiskit-terra==0.18.3 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.18.3)\n", + "Requirement already satisfied: qiskit-aqua==0.9.5 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.9.5)\n", + "Requirement already satisfied: qiskit-ignis==0.6.0 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.6.0)\n", + "Requirement already satisfied: qiskit-aer==0.9.1 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.9.1)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.9.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.4.1)\n", + "Requirement already satisfied: yfinance>=0.1.62 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.1.70)\n", + "Requirement already satisfied: dlx<=1.0.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.0.4)\n", + "Requirement already satisfied: retworkx>=0.8.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.11.0)\n", + "Requirement already satisfied: fastdtw<=0.3.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.3.4)\n", + "Requirement already satisfied: h5py<3.3.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (3.1.0)\n", + "Requirement already satisfied: scikit-learn>=0.20.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.0.2)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.7.1)\n", + "Requirement already satisfied: quandl in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (3.7.0)\n", + "Requirement already satisfied: docplex>=2.21.207 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (2.22.213)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (5.4.8)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.3.5)\n", + "Requirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.24.3)\n", + "Requirement already satisfied: requests-ntlm>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.1.0)\n", + "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.27.1)\n", + "Requirement already satisfied: websocket-client>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.3.1)\n", + "Requirement already satisfied: fastjsonschema>=2.10 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (2.15.3)\n", + "Requirement already satisfied: ply>=3.10 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (3.11)\n", + "Requirement already satisfied: python-constraint>=1.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (1.4.0)\n", + "Requirement already satisfied: jsonschema>=2.6 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (4.3.3)\n", + "Requirement already satisfied: symengine>0.7 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (0.9.0)\n", + "Requirement already satisfied: tweedledum<2.0,>=1.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (1.1.1)\n", + "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py<3.3.0->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.5.2)\n", + "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (5.4.0)\n", + "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (4.11.1)\n", + "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (21.4.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (3.10.0.2)\n", + "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (0.18.1)\n", + "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from importlib-resources>=1.4.0->jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (3.7.0)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.0.12)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2021.10.8)\n", + "Requirement already satisfied: cryptography>=1.3 in /usr/local/lib/python3.7/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (36.0.1)\n", + "Requirement already satisfied: ntlm-auth>=1.0.2 in /usr/local/lib/python3.7/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.5.0)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.15.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.21)\n", + "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.1.0)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (3.1.0)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.7/dist-packages (from sympy>=1.3->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.2.1)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from torchpack>=0.3.0->torchquantum==0.1.0) (3.13)\n", + "Collecting loguru\n", + " Downloading loguru-0.6.0-py3-none-any.whl (58 kB)\n", + "\u001b[K |████████████████████████████████| 58 kB 1.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: tensorboard in /usr/local/lib/python3.7/dist-packages (from torchpack>=0.3.0->torchquantum==0.1.0) (2.8.0)\n", + "Collecting tensorpack\n", + " Downloading tensorpack-0.11-py2.py3-none-any.whl (296 kB)\n", + "\u001b[K |████████████████████████████████| 296 kB 3.6 MB/s \n", + "\u001b[?25hCollecting multimethod\n", + " Downloading multimethod-1.7-py3-none-any.whl (9.5 kB)\n", + "Collecting toml\n", + " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", + "Requirement already satisfied: lxml>=4.5.1 in /usr/local/lib/python3.7/dist-packages (from yfinance>=0.1.62->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (4.8.0)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.7/dist-packages (from yfinance>=0.1.62->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.0.10)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (2018.9)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.7/dist-packages (from quandl->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (8.12.0)\n", + "Requirement already satisfied: inflection>=0.3.1 in /usr/local/lib/python3.7/dist-packages (from quandl->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.5.1)\n", + "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.37.1)\n", + "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.4.6)\n", + "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.6.1)\n", + "Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (3.17.3)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.35.0)\n", + "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.0.1)\n", + "Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.44.0)\n", + "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.0.0)\n", + "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.8.1)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (3.3.6)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (4.2.4)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (4.8)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.2.8)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.3.1)\n", + "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.4.8)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (3.2.0)\n", + "Requirement already satisfied: msgpack>=0.5.2 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (1.0.3)\n", + "Requirement already satisfied: tabulate>=0.7.7 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (0.8.9)\n", + "Collecting msgpack-numpy>=0.4.4.2\n", + " Downloading msgpack_numpy-0.4.7.1-py2.py3-none-any.whl (6.7 kB)\n", + "Requirement already satisfied: pyzmq>=16 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (22.3.0)\n", + "Requirement already satisfied: termcolor>=1.1 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (1.1.0)\n", + "Installing collected packages: msgpack-numpy, toml, tensorpack, ppft, pox, multimethod, loguru, fonttools, torchpack, pathos, matplotlib, torchquantum\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.2.2\n", + " Uninstalling matplotlib-3.2.2:\n", + " Successfully uninstalled matplotlib-3.2.2\n", + " Running setup.py develop for torchquantum\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "albumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\n", + "Successfully installed fonttools-4.29.1 loguru-0.6.0 matplotlib-3.5.1 msgpack-numpy-0.4.7.1 multimethod-1.7 pathos-0.2.8 pox-0.3.0 ppft-1.6.6.4 tensorpack-0.11 toml-0.10.2 torchpack-0.3.1 torchquantum-0.1.0\n" + ] + }, + { + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "matplotlib", + "mpl_toolkits" + ] + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "!pip install --editable ." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "18tqleq4O3cX" + }, + "source": [ + "Change PYTHONPATH and install other packages." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d7ZPp7FikrZz", + "outputId": "9ee13348-41b4-4566-c079-5f2a56a308d8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: PYTHONPATH=.\n" + ] + } + ], + "source": [ + "%env PYTHONPATH=." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rhsBhV23PD4g" + }, + "source": [ + "Run the following code to store a qiskit token. You can replace it with your own token from your IBMQ account if you like.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Iw9rQ6dcnrhe" + }, + "outputs": [], + "source": [ + "from qiskit import IBMQ\n", + "IBMQ.save_account('51a2a5d55d3e1d9683ab4f135fe6fbb84ecf3221765e19adb408699d43c6eaa238265059c3c2955ba59328634ffbd88ba14d5386c947d22eb9a826e40811d626', overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Nvn9EkRH5fTs", + "outputId": "57c475a3-d0aa-431f-9f8c-35cc5ddce22e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib==3.1.3\n", + " Downloading matplotlib-3.1.3-cp37-cp37m-manylinux1_x86_64.whl (13.1 MB)\n", + "\u001b[K |████████████████████████████████| 13.1 MB 6.1 MB/s \n", + "\u001b[?25hRequirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (2.8.2)\n", + "Requirement already satisfied: numpy>=1.11 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (1.21.5)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (0.11.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (1.3.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (3.0.7)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib==3.1.3) (1.15.0)\n", + "Installing collected packages: matplotlib\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.5.1\n", + " Uninstalling matplotlib-3.5.1:\n", + " Successfully uninstalled matplotlib-3.5.1\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torchquantum 0.1.0 requires matplotlib>=3.3.2, but you have matplotlib 3.1.3 which is incompatible.\n", + "albumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\n", + "Successfully installed matplotlib-3.1.3\n" + ] + }, + { + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "matplotlib", + "mpl_toolkits" + ] + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "!pip install matplotlib==3.1.3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sTwecaw_YyCX", + "outputId": "964c52c7-41ea-4443-e831-f6084cba2cf1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aerbackend.py example2 example4 example6 README.md\n", + "example1 example3 example5 example7\n" + ] + } + ], + "source": [ + "!ls artifact" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SNWF7ZlbVwVZ" + }, + "outputs": [], + "source": [ + "!cp artifact/aerbackend.py ../../usr/local/lib/python3.7/dist-packages/qiskit/providers/aer/backends/ -r" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "N5acspJ8G1n3", + "outputId": "f5b55e0a-71ca-44fa-dff3-fdc5b9490249" + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import numpy as np\n", + "\n", + "import torchquantum as tq\n", + "import torchquantum.functional as tqf\n", + "from torchquantum.layer.layers import SethLayer0\n", + "\n", + "from torchquantum.dataset import MNIST\n", + "from torch.optim.lr_scheduler import CosineAnnealingLR" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QiOV-xIGKXVK" + }, + "source": [ + "### Build a quantum model\n", + "Our 4-qubit quantum model contains an encoder that can encode a 4x4 image to quantum state; a quantum layer RZZ+RY+RZZ+RY, 16 parameters in total; and PauliZ measure on each qubit." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "iBnWI5yqKfMB" + }, + "outputs": [], + "source": [ + "class QFCModel(tq.QuantumModule):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.n_wires = 4\n", + " self.encoder = tq.GeneralEncoder(\n", + " tq.encoder_op_list_name_dict['4x4_ryzxy'])\n", + "\n", + " self.arch = {'n_wires': self.n_wires, 'n_blocks': 2, 'n_layers_per_block': 2}\n", + " self.q_layer = SethLayer0(self.arch)\n", + "\n", + " self.measure = tq.MeasureAll(tq.PauliZ)\n", + "\n", + " def forward(self, x, use_qiskit=False):\n", + " bsz = x.shape[0]\n", + " q_device = tq.QuantumDevice(n_wires=self.n_wires, bsz=bsz)\n", + " x = F.avg_pool2d(x, 6).view(bsz, 16)\n", + "\n", + " if use_qiskit:\n", + " x = self.qiskit_processor.process_parameterized(\n", + " q_device, self.encoder, self.q_layer, self.measure, x)\n", + " else:\n", + " self.encoder(q_device, x)\n", + " self.q_layer(q_device)\n", + " x = self.measure(q_device)\n", + "\n", + " x = x.reshape(bsz, 4)\n", + "\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EtE-1nRK70hY" + }, + "source": [ + "### Build the function of parameters shift rules\n", + "\n", + "The function can shift the parameters and calculate the gradients to the expectation value of each measure for each parameter. It returns both the expectaion values and the gradient for each parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "eo91nL5s6IG4" + }, + "outputs": [], + "source": [ + "def shift_and_run(model, inputs, use_qiskit=False):\n", + " param_list = []\n", + " for param in model.parameters():\n", + " param_list.append(param)\n", + " grad_list = []\n", + " for param in param_list:\n", + " param.copy_(param + np.pi * 0.5)\n", + " out1 = model(inputs, use_qiskit)\n", + " param.copy_(param - np.pi)\n", + " out2 = model(inputs, use_qiskit)\n", + " param.copy_(param + np.pi * 0.5)\n", + " grad = 0.5 * (out1 - out2)\n", + " grad_list.append(grad)\n", + " return model(inputs, use_qiskit), grad_list" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LpxOsZrRLUal" + }, + "source": [ + "Set whether using gpu, using cuda, number of epochs, optimizer and scheduler. Initialize the model and the MNIST-36 classification dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 523, + "referenced_widgets": [ + "7912b116e746423eb09337b8779e4596", + "e4aee1dc9cc4422b9a46fd7c3b891c1e", + "a3dd57b01cee4ea4ad42ea50f0fec7e2", + "db515dafb0264e86b3eebbd95815c0f5", + "aaf91412563844d79b52c39c0f1c9a27", + "2cdf641f3e0c473f8292e25be238b775", + "ea68f1055083478f8028ef9f77528ecc", + "0a94560cb838462aa3ab371dff9633ee", + "9d65737db632488091db32e72e81713a", + "9fba1c7cbfef499994fa87ec83e38f4f", + "17dba6206cf04713a4d4fb8e50c251f8", + "474d5db7730a4e6196a596f965ff9eea", + "f156918126d748df8842ddc3a5cfc019", + "29077ee63ae8400fba43d953ce90088e", + "8903c72842294a48afafa28eace2f592", + "b7612723e13e4beca932f61cc64c6de9", + "119658777c3b46df83d0f51e9feafa66", + "134055d175fd4c6e8abb65da74b5cdc0", + "35c6f2a26f4145fbaf7d477565eb4c5c", + "4fe76f9ccfa74ccead52eb188e158c8c", + "7c58305314b9464a917f8f63deb86257", + "6ac0e78521d94dc0b790056bd42f686f", + "d2898cd0ae4741efa2e3ac708a76a091", + "f2a0be6a6c2a42dabc70d15392683334", + "8ecb7c40807647e7ab0e8e0d303e1f71", + "fc39778dcba04ad1b01a445a2ed7d8d2", + "ba9d7af431ef4e52929ffdcf8e0920d6", + "518fea7751344948995ccb701e8f3798", + "0642204f7afe4befaed2577fb23684ce", + "a2380893f25145d8a12a8118ad5c3e9c", + "5c75c06d1dfa4f22beb47df79634efc5", + "4d9264aa3f614c9ea59b049cf83e415f", + "ecb2185981e34dd789f85363bde70775", + "abc5126f11974c92978b7e6ef2802580", + "8c237190ce50450ea763296da6abefb1", + "9e08a5e3ab62449f9420965eb7bbfb7b", + "fb441059487e4cbeaa5c2113606abb0f", + "8bc37933515e4535b4edba3c3a348325", + "224d25aefd124bd3aaae61f169641944", + "7f85ee98f7a14211978e011634716c9f", + "04571b0b33fe4cea82770be70b59f464", + "78f0cd3a0fc247d6b1b9d49dc838a48a", + "222814e1aa664b15be06eda0e1c011dc", + "ee2880bc14a94f5bba5b767d9035da93" + ] + }, + "id": "cmzcsyaCLZf_", + "outputId": "be56e43b-fb3d-4987-f2c5-a1f9d12209c6" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[2023-09-12 07:53:28.866]\u001b[0m \u001b[33m\u001b[1mOnly use the front 5000 images as TRAIN set.\u001b[0m\n", + "\u001b[32m[2023-09-12 07:53:28.966]\u001b[0m \u001b[33m\u001b[1mOnly use the front 3000 images as TEST set.\u001b[0m\n" + ] + } + ], + "source": [ + "use_cuda = torch.cuda.is_available()\n", + "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n", + "model = QFCModel().to(device)\n", + "n_epochs = 15\n", + "optimizer = optim.Adam(model.parameters(), lr=5e-3, weight_decay=1e-4)\n", + "scheduler = CosineAnnealingLR(optimizer, T_max=n_epochs)\n", + "\n", + "dataset = MNIST(\n", + " root='./mnist_data',\n", + " train_valid_split_ratio=[0.9, 0.1],\n", + " digits_of_interest=[3, 6],\n", + " n_test_samples=3000,\n", + " n_train_samples=5000\n", + ")\n", + "\n", + "dataflow = dict()\n", + "for split in dataset:\n", + " sampler = torch.utils.data.RandomSampler(dataset[split])\n", + " dataflow[split] = torch.utils.data.DataLoader(\n", + " dataset[split],\n", + " batch_size=256,\n", + " sampler=sampler,\n", + " num_workers=8,\n", + " pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ckdg6zccLwF3" + }, + "source": [ + "###Train the model.\n", + "\n", + "During each training step, we calculated the gradients twice. First we use back propagation and second we use parameters shift rules." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_kVbTlsfBUef", + "outputId": "d3a76811-72bf-43e9-dc55-72818e4d1bbd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1:\n", + "0.005 0.9950294494628906\n", + "valid set accuracy: 0.3219917012448133\n", + "valid set loss: 0.8985593914985657\n", + "Epoch 2:\n", + "0.0049453690018345149719\n", + "valid set accuracy: 0.36016597510373444\n", + "valid set loss: 0.8457769155502319\n", + "Epoch 3:\n", + "0.0047838636441065028674\n", + "valid set accuracy: 0.4464730290456432\n", + "valid set loss: 0.792057454586029\n", + "Epoch 4:\n", + "0.0045225424859373685277\n", + "valid set accuracy: 0.537759336099585\n", + "valid set loss: 0.7392197251319885\n", + "Epoch 5:\n", + "0.0041728265158971455605\n", + "valid set accuracy: 0.5892116182572614\n", + "valid set loss: 0.6949657797813416\n", + "Epoch 6:\n", + "0.00375.7015460133552551\n", + "valid set accuracy: 0.6190871369294606\n", + "valid set loss: 0.6624241471290588\n", + "Epoch 7:\n", + "0.0032725424859373687749\n", + "valid set accuracy: 0.6423236514522822\n", + "valid set loss: 0.6419368386268616\n", + "Epoch 8:\n", + "0.0027613211581691349373\n", + "valid set accuracy: 0.6572614107883817\n", + "valid set loss: 0.629072368144989\n", + "Epoch 9:\n", + "0.0022386788418308670791\n", + "valid set accuracy: 0.6697095435684647\n", + "valid set loss: 0.620841920375824\n", + "Epoch 10:\n", + "0.0017274575140626327878\n", + "valid set accuracy: 0.6730290456431536\n", + "valid set loss: 0.6155759692192078\n", + "Epoch 11:\n", + "0.0012500000000000007515\n", + "valid set accuracy: 0.6771784232365146\n", + "valid set loss: 0.6119210124015808\n", + "Epoch 12:\n", + "0.0008271734841028553455\n", + "valid set accuracy: 0.6796680497925311\n", + "valid set loss: 0.6096568703651428\n", + "Epoch 13:\n", + "0.0004774575140626316318\n", + "valid set accuracy: 0.6804979253112033\n", + "valid set loss: 0.6084039807319641\n", + "Epoch 14:\n", + "0.0002161363558934975552\n", + "valid set accuracy: 0.6821576763485477\n", + "valid set loss: 0.6078216433525085\n", + "Epoch 15:\n", + "5.463099816548578e-05336\n", + "valid set accuracy: 0.6821576763485477\n", + "valid set loss: 0.607674777507782\n", + "test set accuracy: 0.720020325203252\n", + "test set loss: 0.5852651000022888\n" + ] + } + ], + "source": [ + "grads_bp = []\n", + "grads_ps = []\n", + "\n", + "def train_and_return_grad(dataflow, model, device, optimizer):\n", + " for feed_dict in dataflow['train']:\n", + " inputs = feed_dict['image'].to(device)\n", + " targets = feed_dict['digit'].to(device)\n", + " \n", + " # calculate gradients via back propagation\n", + " outputs = model(inputs)\n", + " prediction = outputs.reshape(-1, 2, 2).sum(-1).squeeze()\n", + " loss = F.nll_loss(F.log_softmax(prediction, dim=1), targets)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " grad_bp = []\n", + " for i, param in enumerate(model.q_layer.parameters()):\n", + " grad_bp.append(param.grad.item())\n", + "\n", + " # calculate gradients via parameters shift rules\n", + " with torch.no_grad():\n", + " outputs, grad_list = shift_and_run(model, inputs)\n", + " outputs.requires_grad=True\n", + " prediction = outputs.reshape(-1, 2, 2).sum(-1).squeeze()\n", + " loss = F.nll_loss(F.log_softmax(prediction, dim=1), targets)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " grad_ps = []\n", + " for i, param in enumerate(model.q_layer.parameters()):\n", + " param.grad = torch.sum(grad_list[i] * outputs.grad).to(dtype=torch.float32, device=param.device).view(param.shape)\n", + " grad_ps.append(param.grad.item())\n", + "\n", + " optimizer.step()\n", + " print(f\"loss: {loss.item()}\", end='\\r')\n", + " grads_bp.append(grad_bp)\n", + " grads_ps.append(grad_ps)\n", + "\n", + "def valid_test(dataflow, split, model, device, qiskit=False):\n", + " target_all = []\n", + " output_all = []\n", + " with torch.no_grad():\n", + " for feed_dict in dataflow[split]:\n", + " inputs = feed_dict['image'].to(device)\n", + " targets = feed_dict['digit'].to(device)\n", + "\n", + " outputs = model(inputs, use_qiskit=qiskit)\n", + " prediction = F.log_softmax(outputs.reshape(-1, 2, 2).sum(-1).squeeze(), dim=1)\n", + "\n", + " target_all.append(targets)\n", + " output_all.append(prediction)\n", + " target_all = torch.cat(target_all, dim=0)\n", + " output_all = torch.cat(output_all, dim=0)\n", + "\n", + " _, indices = output_all.topk(1, dim=1)\n", + " masks = indices.eq(target_all.view(-1, 1).expand_as(indices))\n", + " size = target_all.shape[0]\n", + " corrects = masks.sum().item()\n", + " accuracy = corrects / size\n", + " loss = F.nll_loss(output_all, target_all).item()\n", + "\n", + " print(f\"{split} set accuracy: {accuracy}\")\n", + " print(f\"{split} set loss: {loss}\")\n", + "\n", + "for epoch in range(1, n_epochs + 1):\n", + " # train\n", + " print(f\"Epoch {epoch}:\")\n", + " train_and_return_grad(dataflow, model, device, optimizer)\n", + " print(optimizer.param_groups[0]['lr'])\n", + " # valid\n", + " valid_test(dataflow, 'valid', model, device)\n", + " scheduler.step()\n", + "\n", + "# test\n", + "valid_test(dataflow, 'test', model, device, qiskit=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q9x5zasevzls" + }, + "source": [ + "### Plot and compare the gradients\n", + "\n", + "We have recorded two sets of gradients calculated by back propagation and parameters shift rules respectively. Now let's plot these gradients and we can valid that the gradients calculated by parameters shift rules are exactly the same as those calculated by back propagation. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "XYBYEfVRmeWt", + "outputId": "56998697-f138-40b9-f6f5-227c0ecd5589" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import matplotlib\n", + "\n", + "grads_bp = np.array(grads_bp)\n", + "grads_ps = np.array(grads_ps)\n", + "\n", + "n_steps = grads_bp.shape[0]\n", + "n_params = grads_bp.shape[1]\n", + "\n", + "fig, ax_list = plt.subplots(n_params, 1, sharex=True, figsize=(15, 2 * n_params))\n", + "\n", + "for i, ax in enumerate(ax_list):\n", + " ax.plot(grads_bp[:, i], c=\"#1f77b4\", label=\"back propagation\")\n", + " ax.scatter(range(n_steps), grads_ps[:, i], c=\"#ff7f0e\", marker=\"^\", label=\"parameters shift\")\n", + " ax.set_ylabel(\"grad of param{0}\".format(i))\n", + " ax.set_xlabel(\"Step\")\n", + " ax.legend()\n", + " ax.axhline(color='black', lw=0.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hlVjpUb9fP6O" + }, + "source": [ + "## A simple 2 qubit model for a simple 2 classification task\n", + "\n", + "Firstly we create a dataset. The dataset is a simple 2 classification dataset from [Jiang et al. (2020)](https://arxiv.org/pdf/2006.14815.pdf).\n", + "\n", + "
\n", + "\"conv-full-layer\"\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Q7blg45uTAWC" + }, + "outputs": [], + "source": [ + "from torchpack.datasets.dataset import Dataset\n", + "\n", + "class Classification2Dataset(torch.utils.data.Dataset):\n", + " def __init__(self, num=11):\n", + " self.data = []\n", + " self.target = []\n", + " sum0 = 0\n", + " sum1 = 0\n", + " for x in np.linspace(0, 1, num=num):\n", + " for y in np.linspace(0, 1, num=num):\n", + " self.data.append(torch.tensor([x, y]))\n", + " if (x**2 + y**2 <= 0.55**2 or (x-1)**2 + (y-1)**2 <= 0.55**2):\n", + " self.target.append(1)\n", + " sum1 = sum1 + 1\n", + " else:\n", + " self.target.append(0)\n", + " sum0 = sum0 + 1\n", + " print(self.target[-num:])\n", + "\n", + " def __getitem__(self, idx):\n", + " return {'data': self.data[idx], 'target': self.target[idx]}\n", + "\n", + " def __len__(self):\n", + " return len(self.target) - 1\n", + "\n", + "class Simple2Class(Dataset):\n", + " def __init__(self):\n", + " train_dataset = Classification2Dataset()\n", + " valid_dataset = Classification2Dataset(num=10)\n", + " datasets = {'train': train_dataset, 'valid': valid_dataset, 'test': valid_dataset}\n", + " super().__init__(datasets)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J1hTBSA1JrUu" + }, + "source": [ + "Then we create our quantum circuit\n", + "
\n", + "\"conv-full-layer\"\n", + "
\n", + "\n", + "The circuit only contains three trainable parameters. When executing the model, we firstly transform the input (x, y) to the phase $\\arcsin(\\sqrt{x+y-xy})$ and feed the phase to an RY gate. This is the encoding. After the ansatz, the 2 expectation values from 2 measures are the circuit outputs. Outside the circuit, we add a logsoftmax function to the output and get the predictions of each class." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "20akixa4fPIx" + }, + "outputs": [], + "source": [ + "class Q2Model(tq.QuantumModule):\n", + " class Ansatz(tq.QuantumModule):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.n_wires = 2\n", + " self.op1 = tq.RZ(has_params=True, trainable=True)\n", + " self.op2 = tq.RY(has_params=True, trainable=True)\n", + " self.op3 = tq.RY(has_params=True, trainable=True)\n", + " self.op4 = tq.CNOT(has_params=False, trainable=False)\n", + " \n", + " def forward(self, q_device: tq.QuantumDevice):\n", + " self.q_device = q_device\n", + " self.op1(self.q_device, wires=0)\n", + " self.op2(self.q_device, wires=1)\n", + " self.op3(self.q_device, wires=0)\n", + " self.op4(self.q_device, wires=[0, 1])\n", + "\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.n_wires = 2\n", + " self.q_device = tq.QuantumDevice(n_wires=self.n_wires)\n", + " self.encoder = tq.GeneralEncoder([{'input_idx': [0], 'func': 'ry', 'wires': [0]}])\n", + "\n", + " self.ansatz = self.Ansatz()\n", + "\n", + " self.measure = tq.MeasureAll(tq.PauliZ)\n", + "\n", + " def forward(self, x, use_qiskit=False):\n", + " bsz = x.shape[0]\n", + " data = 2 * torch.arcsin(torch.sqrt(x[:, 0] + x[:, 1] - 2 * x[:, 0] * x[:, 1])).reshape(bsz, 1)\n", + "\n", + " if use_qiskit:\n", + " data = self.qiskit_processor.process_parameterized(\n", + " self.q_device, self.encoder, self.ansatz, self.measure, data)\n", + " else:\n", + " self.encoder(self.q_device, data)\n", + " self.ansatz(self.q_device)\n", + " data = self.measure(self.q_device)\n", + "\n", + " data = data.reshape(bsz, 2)\n", + "\n", + " return data\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FA_uGgwPgObj" + }, + "source": [ + "Load the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A2hYxOfefXTn", + "outputId": "932a6f31-7e0c-4997-cbd2-60a18edb530b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n", + "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 1, 0, 0, 0, 0, 0, 0]\n", + "[1, 1, 1, 0, 0, 0, 0, 0, 0, 0]\n", + "[0, 0, 0, 0, 0, 0, 0, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 0, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n", + "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", + " cpuset_checked))\n" + ] + } + ], + "source": [ + "dataset = Simple2Class()\n", + "dataflow = dict()\n", + "for split in dataset:\n", + " sampler = torch.utils.data.RandomSampler(dataset[split])\n", + " dataflow[split] = torch.utils.data.DataLoader(\n", + " dataset[split],\n", + " batch_size=10,\n", + " sampler=sampler,\n", + " num_workers=8,\n", + " pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-_KlYIsqgQbL" + }, + "source": [ + "Define train and valid function. The model is a 2-qubit model so there is a slightly difference to the process of the circuit output." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TqvdF76rf4XL" + }, + "outputs": [], + "source": [ + "def train_2qubit(dataflow, model, device, optimizer, qiskit=False, input_name = 'data', target_name = 'target'):\n", + " for feed_dict in dataflow['train']:\n", + " inputs = feed_dict[input_name].to(device)\n", + " targets = feed_dict[target_name].to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs, grad_list = shift_and_run(model, inputs, use_qiskit=qiskit)\n", + " outputs.requires_grad=True\n", + " prediction = F.log_softmax(outputs, dim=1)\n", + " loss = F.nll_loss(prediction, targets)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " for i, param in enumerate(model.parameters()):\n", + " param.grad = torch.sum(grad_list[i] * outputs.grad).to(dtype=torch.float32, device=param.device).view(param.shape)\n", + " optimizer.step()\n", + " print(f\"loss: {loss.item()}\", end='\\r')\n", + "\n", + "\n", + "def valid_test_2qubit(dataflow, split, model, device, qiskit=False, input_name = 'data', target_name = 'target'):\n", + " target_all = []\n", + " output_all = []\n", + " with torch.no_grad():\n", + " for feed_dict in dataflow[split]:\n", + " inputs = feed_dict[input_name].to(device)\n", + " targets = feed_dict[target_name].to(device)\n", + "\n", + " outputs = model(inputs, use_qiskit=qiskit)\n", + " prediction = F.log_softmax(outputs, dim=1)\n", + "\n", + " target_all.append(targets)\n", + " output_all.append(prediction)\n", + " target_all = torch.cat(target_all, dim=0)\n", + " output_all = torch.cat(output_all, dim=0)\n", + "\n", + " _, indices = output_all.topk(1, dim=1)\n", + " masks = indices.eq(target_all.view(-1, 1).expand_as(indices))\n", + " size = target_all.shape[0]\n", + " corrects = masks.sum().item()\n", + " accuracy = corrects / size\n", + " loss = F.nll_loss(output_all, target_all).item()\n", + "\n", + " print(f\"{split} set accuracy: {accuracy}\")\n", + " print(f\"{split} set loss: {loss}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ycs5rJMNgoYh" + }, + "source": [ + "Train and valid the model on ibmq_quito. You need to import `QiskitProcessor` from `torchquantum.plugin` to create a processor that handles your access to real quantum computer. You can set whether use real quantum computer or qiskit's noise model, and the backend of your quantum computer. Call `model.set_qiskit_processor` to attach the processor to your model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true, + "base_uri": "https://localhost:8080/" + }, + "id": "wdMKCOaZft0E", + "outputId": "9aec13c7-5ed9-426e-94ee-11fe3d7dddf4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", + " cpuset_checked))\n", + "/usr/local/lib/python3.7/dist-packages/qiskit/circuit/quantumcircuit.py:933: DeprecationWarning: The QuantumCircuit.combine() method is being deprecated. Use the compose() method which is more flexible w.r.t circuit register compatibility.\n", + " return self.combine(rhs)\n", + "[2022-03-02 05:03:08.183] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 05:03:08.472] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (18) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:07:04.863] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:07:04.885] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (17) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:10:45.202] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:10:45.220] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:16:00.892] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:16:00.912] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:19:42.755] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:19:42.778] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (14) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:23:10.114] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:23:10.137] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (14) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:24:51.741] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:24:51.767] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (13) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:28:21.188] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:28:21.242] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:32:01.063] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:32:01.088] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:35:51.696] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:35:51.770] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:45:21.062] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:45:21.132] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 09:55:17.874] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 09:55:17.901] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 10:05:40.990] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 10:05:41.011] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 11:46:53.672] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 11:46:53.694] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 11:56:33.439] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 11:56:33.463] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 12:07:13.294] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 12:07:13.314] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (14) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 12:16:33.349] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 12:16:33.373] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (13) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 12:20:43.430] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 12:20:43.499] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 12:30:34.169] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 12:30:34.252] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 12:36:42.971] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 12:36:42.991] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 12:40:23.251] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 12:40:23.276] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 13:08:24.755] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 13:08:24.779] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 13:54:44.675] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 13:54:44.696] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 13:58:23.983] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 13:58:24.006] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (13) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:09:04.009] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:09:04.079] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:12:44.205] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:12:44.226] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:16:23.556] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:16:23.577] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:20:04.063] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:20:04.083] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:23:44.058] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:23:44.151] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:28:15.393] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:28:15.414] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:32:06.613] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:32:06.637] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:42:25.762] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:42:25.783] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (15) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:52:56.361] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:52:56.387] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (17) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 14:53:56.366] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 14:53:56.393] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:05:35.743] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:05:35.783] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (19) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:15:45.472] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:15:45.492] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:17:24.834] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:17:24.852] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (19) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:27:16.382] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:27:16.405] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (21) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:29:50.433] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:29:50.458] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (21) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:31:56.050] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:31:56.072] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:34:26.703] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:34:26.724] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:36:45.595] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:36:45.618] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:39:15.354] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:39:15.378] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:48:56.005] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:48:56.029] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (21) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 15:50:45.708] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 15:50:45.727] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (20) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:00:26.978] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:00:27.000] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (21) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:02:36.243] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:02:36.269] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (20) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:03:16.094] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:03:16.115] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:05:05.797] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:05:05.822] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (19) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:06:56.090] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:06:56.113] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:16:36.369] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:16:36.393] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (23) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:18:26.440] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:18:26.463] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:20:26.218] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:20:26.243] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (22) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:27:16.190] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:27:16.210] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (21) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:29:16.272] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:29:16.334] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (20) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:39:15.345] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:39:15.370] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (18) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:41:15.622] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:41:15.646] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:43:36.314] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:43:36.340] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:46:06.862] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:46:06.887] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:48:25.597] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:48:25.616] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (15) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 16:50:56.397] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 16:50:56.425] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (14) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:02:46.871] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:02:46.896] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (18) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:13:13.351] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:13:13.373] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:13:58.825] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:13:58.849] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:15:47.488] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:15:47.510] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (17) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:17:15.990] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:17:16.099] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:27:06.069] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:27:06.092] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:37:17.048] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:37:17.073] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:39:06.751] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:39:06.776] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:48:56.162] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:48:56.180] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:51:16.778] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:51:16.803] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:53:46.496] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:53:46.519] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:56:06.057] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:56:06.081] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 17:58:36.793] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 17:58:36.819] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (16) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:02:55.920] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:02:55.945] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:04:46.666] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:04:46.690] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (13) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:05:26.258] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:05:26.308] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (13) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:06:07.303] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:06:07.331] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:07:44.036] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:07:44.058] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:09:19.642] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:09:19.667] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:18:56.005] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:18:56.026] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:28:46.057] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:28:46.083] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:38:27.342] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:38:27.410] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:48:35.734] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:48:35.756] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n", + "0.05\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", + " cpuset_checked))\n", + "[2022-03-02 18:51:06.781] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:51:06.812] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:53:27.365] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:53:27.445] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:55:46.501] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:55:46.526] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:58:16.855] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:58:16.883] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:58:56.647] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:58:56.674] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 18:59:49.658] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 18:59:49.680] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:03:20.134] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:03:20.161] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:04:56.306] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:04:56.332] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:05:36.655] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:05:36.681] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "kvTdBipl6gqY" - }, - "source": [ - "###Outline\n", - "1. Introduction to Parameters Shift Rules.\n", - "2. Train a model with parameters shift rules.\n", - "3. A simple 2 qubit model for a simple 2 classification task.\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:09:06.636] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:09:06.657] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "qJv0wED75YTq" - }, - "source": [ - "\n", - "In this tutorial, you can learn parameters shift rules and how to use parameters shift rules to calculate gradients and use the gradient to train a model.\n", - "\n", - "##Introduction to Parameters Shift Rules\n", - "\n", - "###Back Propagation\n", - "\n", - "Previously, our quantum model was based on qiskit and pytorch. Once we did an inference of the model, pytorch will automatically build a computaional graph. We can calculate the gradients of each node in the computational graph in a reversed order based on the chain rule. This is called back propagation.\n", - "
\n", - "\"conv-full-layer\"\n", - "
\n", - "\n", - "###Parameters Shift Rules\n", - "\n", - "As we all know, when executing a quantum circuit on a real quantum machine, we can not observe the intermdiate quantum state. So, back propagation to calculate gradients are impossible when our circuits run on real quantum machines. Parameters shift rules offer us a technique to calculate gradients only by doing inference. For a circuit function $f(\\theta)$, we can calculate $f'(\\theta)$ by shifting $\\theta$ twice and minus one result by the other and multiply with a factor. The figure below describes the workflow of how to calculate the gradient of a parameter in a 4-qubit circuit.\n", - "\n", - "
\n", - "\"conv-full-layer\"\n", - "
\n", - "\n", - "Suppose an $m$-qubit quantum circuit is parametrized by $n$ parameters $\\theta=[\\theta_1,\\cdots,\\theta_i,\\cdots,\\theta_n]$, the expectation value of measures of this circuit can be represented by a circuit function,\n", - "$$f(\\theta)=\\langle\\psi|U(\\theta_i)^{\\dagger}\\widehat{Q}U(\\theta_i)|\\psi\\rangle, \\quad f(\\theta)\\in\\mathbb{R}^{m}, \\theta\\in\\mathbb{R}^n.\n", - "$$\n", - "where $\\theta_i$ is the scalar parameter whose gradient is to be calculated, and $U(\\theta_i)$ is the gate where $\\theta_i$ lies in. \n", - "\n", - "Here, for notation simplicity, we have already absorbed the unitaries before $U(\\theta_i)$ into $\\langle\\psi|$, $|\\psi\\rangle$.\n", - "Unitaries after $U(\\theta_i)$ and observables are fused into $\\widehat{Q}$.\n", - "\n", - "Usually, the rotation gates used in QNN can be written in the form $U(\\theta_i)=e^{-\\frac{i}{2}\\theta_i H}$. Here $H$ is the Hermitian generator of $U$ with only 2 unique eigenvalues +1 and -1.\n", - "\n", - "In this way, the gradients of the circuit function $f$ with respect to $\\theta_i$ are,\n", - "$$ \\begin{aligned}\n", - " &\\frac{\\partial f(\\theta)}{\\partial \\theta_i}=\\frac{1}{2}\\Big(f\\big(\\theta_+\\big)-f\\big(\\theta_{-}\\big)\\Big), \\\\ &\\theta_+=[\\theta_1,\\cdots,\\theta_i+\\frac{\\pi}{2},\\cdots,\\theta_n], \\theta_{-}=[\\theta_1,\\cdots,\\theta_i-\\frac{\\pi}{2},\\cdots,\\theta_n],\n", - " \\end{aligned}\n", - "$$\n", - "where $\\theta_+$ and $\\theta_{-}$ are the **positive shift** and **negative shift** of $\\theta$.\n", - "\n", - "Note that this parameter shift rule is **fundamentally different** from any numerical difference methods that only approximate the directional derivatives.\n", - "Instead, the equation calculates the **exact** gradient w.r.t $\\theta_i$ without any approximation errors or numerical issues. \n", - "\n", - "We apply $\\text{softmax}$ on $f(\\theta)$ as the predicted probability for each class. \n", - "Then we calculate the cross entropy between the predicted probability distribution $p$ and the target distribution $t$ as the classification loss $\\mathcal{L}$, \n", - "$$ \\mathcal{L}(\\theta)=-t^T\\cdot\\texttt{softmax}(f(\\theta))=-\\sum_{j=1}^m t_j \\log{p_j},\\quad p_j=\\frac{e^{f_j(\\theta)}}{\\sum_{j=1}^m e^{f_j(\\theta)}}.\n", - "$$\n", - "\n", - "Then the gradient of the loss function with respect to $\\theta_i$ is $\\frac{\\partial\\mathcal{L}(\\theta)}{\\partial \\theta_i}=\\big(\\frac{\\partial\\mathcal{L}(\\theta)}{\\partial f(\\theta)}\\big)^T\\frac{\\partial f(\\theta)}{\\partial \\theta_i}$.\n", - "\n", - "Here $\\frac{\\partial f(\\theta)}{\\partial \\theta_i}$ can be calculated on real quantum computer by the parameter shift rules, and $\\frac{\\partial\\mathcal{L}(\\theta)}{\\partial f(\\theta)}$ can be efficiently calculated on classical devices using backpropagation supported by automatic differentiation frameworks, e.g., PyTorch and TensorFlow.\n", - "\n", - "Now we derive the parameter shift rules used in our QNN models.\n", - "\n", - "Assume $U(\\theta_i)=R_X(\\theta_i),R_X(\\alpha)=e^{-\\frac{i}{2}\\alpha X}$, where $X$ is the Pauli-X matrix.\n", - "\n", - "Firstly, the RX gate is,\n", - "$$ \\begin{aligned}\n", - "R_X(\\alpha)&=e^{-\\frac{i}{2}\\alpha X}=\\sum_{k=0}^{\\infty}(-i\\alpha/2)^kX^k/k!\\\\\n", - "&=\\sum_{k=0}^{\\infty}(-i\\alpha/2)^{2k}X^{2k}/(2k)!+\\sum_{k=0}^{\\infty}(-i\\alpha/2)^{2k+1}X^{2k+1}/(2k+1)!\\\\\n", - "&=\\sum_{k=0}^{\\infty}(-1)^k(\\alpha/2)^{2k}I/(2k)!-i\\sum_{k=0}^{\\infty}(-1)^k(\\alpha/2)^{2k+1}X/(2k+1)!\\\\\n", - "&=\\cos(\\alpha/2)I-i\\sin(\\alpha/2)X.\n", - "\\end{aligned}\n", - "$$\n", - "\n", - "Let $\\alpha=\\frac{\\pi}{2}$, $R_X(\\pm\\frac{\\pi}{2})=\\frac{1}{\\sqrt{2}}(I\\mp iX)$.\n", - "\n", - "As $f(\\theta)=\\langle\\psi|R_X(\\theta_i)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle$, $R_X(\\alpha)R_X(\\beta)=R_X(\\alpha+\\beta)$, and $\\frac{\\partial}{\\partial \\alpha}R_X(\\alpha)=-\\frac{i}{2}XR_X(\\alpha)$,\n", - "we have\n", - "$$\\begin{aligned}\n", - "\\frac{\\partial f(\\theta)}{\\partial \\theta_i}\n", - "% &=\\langle\\psi|\\frac{\\partial}{\\partial \\theta_i}R_X(\\theta_i)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle+\\langle\\psi|R_X(\\theta_i)^{\\dag}\\widehat{Q}\\frac{\\partial}{\\partial \\theta_i}R_X(\\theta_i)|\\psi\\rangle\\\\\n", - "=&\\langle\\psi|R_X(\\theta_i)^{\\dagger}(-\\frac{i}{2}X)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle+\\langle\\psi|R_X(\\theta_i)^{\\dagger}\\widehat{Q}(-\\frac{i}{2}X)R_X(\\theta_i)|\\psi\\rangle\\\\\n", - "% &=\\frac{1}{2}(\\langle\\psi|R_X(\\theta_i)^{\\dagger}(-iX)^{\\dagger}\\widehat{Q}R_X(\\theta_i)|\\psi\\rangle+\\langle\\psi|R_X(\\theta_i)^{\\dagger}\\widehat{Q}(-iX)R_X(\\theta_i)|\\psi\\rangle)\\\\\n", - "=&\\frac{1}{4}(\\langle\\psi|R_X(\\theta_i)^{\\dagger}(I-iX)^{\\dagger}\\widehat{Q}(I-iX)R_X(\\theta_i)|\\psi\\rangle\\\\&-\\langle\\psi|R_X(\\theta_i)^{\\dagger}(I+iX)^{\\dagger}\\widehat{Q}(I+iX)R_X(\\theta_i)|\\psi\\rangle)\\\\\n", - "=&\\frac{1}{2}(\\langle\\psi|R_X(\\theta_i)^{\\dagger}R_X(\\frac{\\pi}{2})^{\\dagger}\\widehat{Q}R_X(\\frac{\\pi}{2})R_X(\\theta_i)|\\psi\\rangle\\\\&-\\langle\\psi|R_X(\\theta_i)^{\\dagger}R_X(-\\frac{\\pi}{2})^{\\dagger}\\widehat{Q}R_X(-\\frac{\\pi}{2})R_X(\\theta_i)|\\psi\\rangle)\\\\\n", - "=&\\frac{1}{2}(f(\\theta_+)-f(\\theta_-)).\n", - "\\end{aligned}\n", - "$$\n", - "\n", - "Without loss of generality, the derivation holds for all unitaries of the form $e^{-\\frac{i}{2}\\alpha H}$, e.g., RX, RY, RZ, XX, YY, ZZ, where $H$ is a Hermitian matrix with only 2 unique eigenvalues +1 and -1.\n" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n", + "valid set accuracy: 0.9494949494949495\n", + "valid set loss: 0.47831726414734255\n", + "Epoch 2:\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "-42mdL8CG5Vi" - }, - "source": [ - "##Train a model with parameters shift rules" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:09:46.487] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:09:46.519] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "pfwd2SNaOA4z" - }, - "source": [ - "###Installation\n", - "Firstly, install qiskit." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "9ELpIlt-3HG8" - }, - "source": [ - "" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:12:16.753] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:12:16.773] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "azb47tvSiaBp", - "outputId": "23c9c3f2-f8a5-45f6-d04d-811d798022e8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting qiskit==0.32.1\n", - " Downloading qiskit-0.32.1.tar.gz (13 kB)\n", - "Collecting qiskit-terra==0.18.3\n", - " Downloading qiskit_terra-0.18.3-cp37-cp37m-manylinux2010_x86_64.whl (6.1 MB)\n", - "\u001b[K |████████████████████████████████| 6.1 MB 7.5 MB/s \n", - "\u001b[?25hCollecting qiskit-aer==0.9.1\n", - " Downloading qiskit_aer-0.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (17.9 MB)\n", - "\u001b[K |████████████████████████████████| 17.9 MB 565 kB/s \n", - "\u001b[?25hCollecting qiskit-ibmq-provider==0.18.1\n", - " Downloading qiskit_ibmq_provider-0.18.1-py3-none-any.whl (237 kB)\n", - "\u001b[K |████████████████████████████████| 237 kB 47.9 MB/s \n", - "\u001b[?25hCollecting qiskit-ignis==0.6.0\n", - " Downloading qiskit_ignis-0.6.0-py3-none-any.whl (207 kB)\n", - "\u001b[K |████████████████████████████████| 207 kB 51.1 MB/s \n", - "\u001b[?25hCollecting qiskit-aqua==0.9.5\n", - " Downloading qiskit_aqua-0.9.5-py3-none-any.whl (2.1 MB)\n", - "\u001b[K |████████████████████████████████| 2.1 MB 40.3 MB/s \n", - "\u001b[?25hRequirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.9.1->qiskit==0.32.1) (1.21.5)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.9.1->qiskit==0.32.1) (1.4.1)\n", - "Collecting quandl\n", - " Downloading Quandl-3.7.0-py2.py3-none-any.whl (26 kB)\n", - "Requirement already satisfied: setuptools>=40.1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (57.4.0)\n", - "Requirement already satisfied: fastdtw<=0.3.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (0.3.4)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (1.7.1)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (1.3.5)\n", - "Requirement already satisfied: scikit-learn>=0.20.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (1.0.2)\n", - "Collecting docplex>=2.21.207\n", - " Downloading docplex-2.22.213.tar.gz (634 kB)\n", - "\u001b[K |████████████████████████████████| 634 kB 49.0 MB/s \n", - "\u001b[?25hCollecting dlx<=1.0.4\n", - " Downloading dlx-1.0.4.tar.gz (5.5 kB)\n", - "Collecting yfinance>=0.1.62\n", - " Downloading yfinance-0.1.70-py2.py3-none-any.whl (26 kB)\n", - "Requirement already satisfied: h5py<3.3.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (3.1.0)\n", - "Collecting retworkx>=0.8.0\n", - " Downloading retworkx-0.11.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.6 MB)\n", - "\u001b[K |████████████████████████████████| 1.6 MB 45.4 MB/s \n", - "\u001b[?25hRequirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit==0.32.1) (5.4.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.8.2)\n", - "Requirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (1.24.3)\n", - "Collecting websocket-client>=1.0.1\n", - " Downloading websocket_client-1.3.1-py3-none-any.whl (54 kB)\n", - "\u001b[K |████████████████████████████████| 54 kB 2.7 MB/s \n", - "\u001b[?25hRequirement already satisfied: requests>=2.19 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.23.0)\n", - "Collecting requests-ntlm>=1.1.0\n", - " Downloading requests_ntlm-1.1.0-py2.py3-none-any.whl (5.7 kB)\n", - "Collecting symengine>0.7\n", - " Downloading symengine-0.9.0-cp37-cp37m-manylinux2010_x86_64.whl (37.5 MB)\n", - "\u001b[K |████████████████████████████████| 37.5 MB 1.3 MB/s \n", - "\u001b[?25hCollecting fastjsonschema>=2.10\n", - " Downloading fastjsonschema-2.15.3-py3-none-any.whl (22 kB)\n", - "Collecting python-constraint>=1.4\n", - " Downloading python-constraint-1.4.0.tar.bz2 (18 kB)\n", - "Collecting ply>=3.10\n", - " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", - "\u001b[K |████████████████████████████████| 49 kB 5.5 MB/s \n", - "\u001b[?25hRequirement already satisfied: jsonschema>=2.6 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit==0.32.1) (4.3.3)\n", - "Collecting tweedledum<2.0,>=1.1\n", - " Downloading tweedledum-1.1.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (943 kB)\n", - "\u001b[K |████████████████████████████████| 943 kB 43.9 MB/s \n", - "\u001b[?25hRequirement already satisfied: dill>=0.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit==0.32.1) (0.3.4)\n", - "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from docplex>=2.21.207->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.15.0)\n", - "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py<3.3.0->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.5.2)\n", - "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (5.4.0)\n", - "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (0.18.1)\n", - "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (4.11.1)\n", - "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (21.4.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (3.10.0.2)\n", - "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from importlib-resources>=1.4.0->jsonschema>=2.6->qiskit-terra==0.18.3->qiskit==0.32.1) (3.7.0)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.10)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2021.10.8)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (3.0.4)\n", - "Collecting cryptography>=1.3\n", - " Downloading cryptography-36.0.1-cp36-abi3-manylinux_2_24_x86_64.whl (3.6 MB)\n", - "\u001b[K |████████████████████████████████| 3.6 MB 44.8 MB/s \n", - "\u001b[?25hCollecting ntlm-auth>=1.0.2\n", - " Downloading ntlm_auth-1.5.0-py2.py3-none-any.whl (29 kB)\n", - "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (1.15.0)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.21)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit==0.32.1) (3.1.0)\n", - "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.1.0)\n", - "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.7/dist-packages (from sympy>=1.3->qiskit-aqua==0.9.5->qiskit==0.32.1) (1.2.1)\n", - "Collecting requests>=2.19\n", - " Downloading requests-2.27.1-py2.py3-none-any.whl (63 kB)\n", - "\u001b[K |████████████████████████████████| 63 kB 1.8 MB/s \n", - "\u001b[?25hRequirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.7/dist-packages (from yfinance>=0.1.62->qiskit-aqua==0.9.5->qiskit==0.32.1) (0.0.10)\n", - "Collecting lxml>=4.5.1\n", - " Downloading lxml-4.8.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl (6.4 MB)\n", - "\u001b[K |████████████████████████████████| 6.4 MB 20.2 MB/s \n", - "\u001b[?25hRequirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->qiskit-aqua==0.9.5->qiskit==0.32.1) (2018.9)\n", - "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit==0.32.1) (2.0.12)\n", - "Requirement already satisfied: more-itertools in /usr/local/lib/python3.7/dist-packages (from quandl->qiskit-aqua==0.9.5->qiskit==0.32.1) (8.12.0)\n", - "Collecting inflection>=0.3.1\n", - " Downloading inflection-0.5.1-py2.py3-none-any.whl (9.5 kB)\n", - "Building wheels for collected packages: qiskit, dlx, docplex, python-constraint\n", - " Building wheel for qiskit (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for qiskit: filename=qiskit-0.32.1-py3-none-any.whl size=11777 sha256=c8dd0aa33407d766de6e21a79c560a28d3aaed47ab5efde37ac60f61f0fc3275\n", - " Stored in directory: /root/.cache/pip/wheels/0f/62/0a/c53eda1ead41c137c47c9730bc2771a8367b1ce00fb64e8cc6\n", - " Building wheel for dlx (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for dlx: filename=dlx-1.0.4-py3-none-any.whl size=5718 sha256=88e879a69472bf6f871793f7a320337f70c30e734a308266be28dd0b5eb1d388\n", - " Stored in directory: /root/.cache/pip/wheels/78/55/c8/dc61e772445a566b7608a476d151e9dcaf4e092b01b0c4bc3c\n", - " Building wheel for docplex (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for docplex: filename=docplex-2.22.213-py3-none-any.whl size=696882 sha256=8a296841fded71c4005ec13d2237a5fcd0dc925f2debdbb6d9198745aa27fd30\n", - " Stored in directory: /root/.cache/pip/wheels/90/69/6b/1375c68a5b7ff94c40263b151c86f58bd72200bf0c465b5ba3\n", - " Building wheel for python-constraint (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for python-constraint: filename=python_constraint-1.4.0-py2.py3-none-any.whl size=24081 sha256=1e63dc909ecdff23baaaf9c6950a9f43558f4cbfddb001c3cb6eae6209ba594c\n", - " Stored in directory: /root/.cache/pip/wheels/07/27/db/1222c80eb1e431f3d2199c12569cb1cac60f562a451fe30479\n", - "Successfully built qiskit dlx docplex python-constraint\n", - "Installing collected packages: tweedledum, symengine, retworkx, python-constraint, ply, fastjsonschema, requests, qiskit-terra, ntlm-auth, lxml, inflection, cryptography, yfinance, websocket-client, requests-ntlm, quandl, qiskit-ignis, docplex, dlx, qiskit-ibmq-provider, qiskit-aqua, qiskit-aer, qiskit\n", - " Attempting uninstall: requests\n", - " Found existing installation: requests 2.23.0\n", - " Uninstalling requests-2.23.0:\n", - " Successfully uninstalled requests-2.23.0\n", - " Attempting uninstall: lxml\n", - " Found existing installation: lxml 4.2.6\n", - " Uninstalling lxml-4.2.6:\n", - " Successfully uninstalled lxml-4.2.6\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "google-colab 1.0.0 requires requests~=2.23.0, but you have requests 2.27.1 which is incompatible.\n", - "datascience 0.10.6 requires folium==0.2.1, but you have folium 0.8.3 which is incompatible.\u001b[0m\n", - "Successfully installed cryptography-36.0.1 dlx-1.0.4 docplex-2.22.213 fastjsonschema-2.15.3 inflection-0.5.1 lxml-4.8.0 ntlm-auth-1.5.0 ply-3.11 python-constraint-1.4.0 qiskit-0.32.1 qiskit-aer-0.9.1 qiskit-aqua-0.9.5 qiskit-ibmq-provider-0.18.1 qiskit-ignis-0.6.0 qiskit-terra-0.18.3 quandl-3.7.0 requests-2.27.1 requests-ntlm-1.1.0 retworkx-0.11.0 symengine-0.9.0 tweedledum-1.1.1 websocket-client-1.3.1 yfinance-0.1.70\n" - ] - } - ], - "source": [ - "!pip install qiskit==0.32.1" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "F2-0UpluOIQl" - }, - "source": [ - "Download and cd to the repo." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:15:15.180] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:15:15.210] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "6sNqLl9tjjAf", - "outputId": "13bc623b-7e1f-4e26-bc94-b2f787bcb1d2" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cloning into 'torchquantum'...\n", - "remote: Enumerating objects: 10900, done.\u001b[K\n", - "remote: Counting objects: 100% (7692/7692), done.\u001b[K\n", - "remote: Compressing objects: 100% (3901/3901), done.\u001b[K\n", - "remote: Total 10900 (delta 3851), reused 7185 (delta 3382), pack-reused 3208\u001b[K\n", - "Receiving objects: 100% (10900/10900), 5.19 MiB | 16.99 MiB/s, done.\n", - "Resolving deltas: 100% (5818/5818), done.\n" - ] - } - ], - "source": [ - "!git clone https://github.com/mit-han-lab/torchquantum.git" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0c2MCqFXjxkD", - "outputId": "8c41b140-edeb-4bb0-b725-907e0f5b0f97" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/content/torchquantum\n" - ] - } - ], - "source": [ - "%cd torchquantum" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:17:36.772] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:17:36.817] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "PO1xLbaOOxWk" - }, - "source": [ - "Install torch-quantum." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (12) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3c6nfq3KkVXG", - "outputId": "792edc41-4ca4-4ede-eed3-0cff8f56dc53" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Obtaining file:///content/torchquantum\n", - "Requirement already satisfied: numpy>=1.19.2 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (1.21.5)\n", - "Requirement already satisfied: torchvision>=0.9.0.dev20210130 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (0.11.1+cu111)\n", - "Requirement already satisfied: tqdm>=4.56.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (4.62.3)\n", - "Requirement already satisfied: setuptools>=52.0.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (57.4.0)\n", - "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (1.10.0+cu111)\n", - "Collecting torchpack>=0.3.0\n", - " Downloading torchpack-0.3.1-py3-none-any.whl (34 kB)\n", - "Requirement already satisfied: qiskit>=0.32.0 in /usr/local/lib/python3.7/dist-packages (from torchquantum==0.1.0) (0.32.1)\n", - "Collecting matplotlib>=3.3.2\n", - " Downloading matplotlib-3.5.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (11.2 MB)\n", - "\u001b[K |████████████████████████████████| 11.2 MB 12.1 MB/s \n", - "\u001b[?25hCollecting pathos>=0.2.7\n", - " Downloading pathos-0.2.8-py2.py3-none-any.whl (81 kB)\n", - "\u001b[K |████████████████████████████████| 81 kB 10.9 MB/s \n", - "\u001b[?25hCollecting fonttools>=4.22.0\n", - " Downloading fonttools-4.29.1-py3-none-any.whl (895 kB)\n", - "\u001b[K |████████████████████████████████| 895 kB 45.1 MB/s \n", - "\u001b[?25hRequirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (2.8.2)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (1.3.2)\n", - "Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (3.0.7)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (0.11.0)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (21.3)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.3.2->torchquantum==0.1.0) (7.1.2)\n", - "Requirement already satisfied: multiprocess>=0.70.12 in /usr/local/lib/python3.7/dist-packages (from pathos>=0.2.7->torchquantum==0.1.0) (0.70.12.2)\n", - "Collecting ppft>=1.6.6.4\n", - " Downloading ppft-1.6.6.4-py3-none-any.whl (65 kB)\n", - "\u001b[K |████████████████████████████████| 65 kB 3.5 MB/s \n", - "\u001b[?25hCollecting pox>=0.3.0\n", - " Downloading pox-0.3.0-py2.py3-none-any.whl (30 kB)\n", - "Requirement already satisfied: dill>=0.3.4 in /usr/local/lib/python3.7/dist-packages (from pathos>=0.2.7->torchquantum==0.1.0) (0.3.4)\n", - "Requirement already satisfied: six>=1.7.3 in /usr/local/lib/python3.7/dist-packages (from ppft>=1.6.6.4->pathos>=0.2.7->torchquantum==0.1.0) (1.15.0)\n", - "Requirement already satisfied: qiskit-ibmq-provider==0.18.1 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.18.1)\n", - "Requirement already satisfied: qiskit-terra==0.18.3 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.18.3)\n", - "Requirement already satisfied: qiskit-aqua==0.9.5 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.9.5)\n", - "Requirement already satisfied: qiskit-ignis==0.6.0 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.6.0)\n", - "Requirement already satisfied: qiskit-aer==0.9.1 in /usr/local/lib/python3.7/dist-packages (from qiskit>=0.32.0->torchquantum==0.1.0) (0.9.1)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aer==0.9.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.4.1)\n", - "Requirement already satisfied: yfinance>=0.1.62 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.1.70)\n", - "Requirement already satisfied: dlx<=1.0.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.0.4)\n", - "Requirement already satisfied: retworkx>=0.8.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.11.0)\n", - "Requirement already satisfied: fastdtw<=0.3.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.3.4)\n", - "Requirement already satisfied: h5py<3.3.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (3.1.0)\n", - "Requirement already satisfied: scikit-learn>=0.20.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.0.2)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.7.1)\n", - "Requirement already satisfied: quandl in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (3.7.0)\n", - "Requirement already satisfied: docplex>=2.21.207 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (2.22.213)\n", - "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (5.4.8)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.3.5)\n", - "Requirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.24.3)\n", - "Requirement already satisfied: requests-ntlm>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.1.0)\n", - "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.27.1)\n", - "Requirement already satisfied: websocket-client>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.3.1)\n", - "Requirement already satisfied: fastjsonschema>=2.10 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (2.15.3)\n", - "Requirement already satisfied: ply>=3.10 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (3.11)\n", - "Requirement already satisfied: python-constraint>=1.4 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (1.4.0)\n", - "Requirement already satisfied: jsonschema>=2.6 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (4.3.3)\n", - "Requirement already satisfied: symengine>0.7 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (0.9.0)\n", - "Requirement already satisfied: tweedledum<2.0,>=1.1 in /usr/local/lib/python3.7/dist-packages (from qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (1.1.1)\n", - "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py<3.3.0->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.5.2)\n", - "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (5.4.0)\n", - "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (4.11.1)\n", - "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (21.4.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (3.10.0.2)\n", - "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (0.18.1)\n", - "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from importlib-resources>=1.4.0->jsonschema>=2.6->qiskit-terra==0.18.3->qiskit>=0.32.0->torchquantum==0.1.0) (3.7.0)\n", - "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.0.12)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.10)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2021.10.8)\n", - "Requirement already satisfied: cryptography>=1.3 in /usr/local/lib/python3.7/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (36.0.1)\n", - "Requirement already satisfied: ntlm-auth>=1.0.2 in /usr/local/lib/python3.7/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.5.0)\n", - "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (1.15.0)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.18.1->qiskit>=0.32.0->torchquantum==0.1.0) (2.21)\n", - "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.1.0)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (3.1.0)\n", - "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.7/dist-packages (from sympy>=1.3->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (1.2.1)\n", - "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from torchpack>=0.3.0->torchquantum==0.1.0) (3.13)\n", - "Collecting loguru\n", - " Downloading loguru-0.6.0-py3-none-any.whl (58 kB)\n", - "\u001b[K |████████████████████████████████| 58 kB 1.6 MB/s \n", - "\u001b[?25hRequirement already satisfied: tensorboard in /usr/local/lib/python3.7/dist-packages (from torchpack>=0.3.0->torchquantum==0.1.0) (2.8.0)\n", - "Collecting tensorpack\n", - " Downloading tensorpack-0.11-py2.py3-none-any.whl (296 kB)\n", - "\u001b[K |████████████████████████████████| 296 kB 3.6 MB/s \n", - "\u001b[?25hCollecting multimethod\n", - " Downloading multimethod-1.7-py3-none-any.whl (9.5 kB)\n", - "Collecting toml\n", - " Downloading toml-0.10.2-py2.py3-none-any.whl (16 kB)\n", - "Requirement already satisfied: lxml>=4.5.1 in /usr/local/lib/python3.7/dist-packages (from yfinance>=0.1.62->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (4.8.0)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.7/dist-packages (from yfinance>=0.1.62->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.0.10)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (2018.9)\n", - "Requirement already satisfied: more-itertools in /usr/local/lib/python3.7/dist-packages (from quandl->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (8.12.0)\n", - "Requirement already satisfied: inflection>=0.3.1 in /usr/local/lib/python3.7/dist-packages (from quandl->qiskit-aqua==0.9.5->qiskit>=0.32.0->torchquantum==0.1.0) (0.5.1)\n", - "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.37.1)\n", - "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.4.6)\n", - "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.6.1)\n", - "Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (3.17.3)\n", - "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.35.0)\n", - "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.0.1)\n", - "Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.44.0)\n", - "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.0.0)\n", - "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.8.1)\n", - "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (3.3.6)\n", - "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (4.2.4)\n", - "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (4.8)\n", - "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.2.8)\n", - "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (1.3.1)\n", - "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (0.4.8)\n", - "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard->torchpack>=0.3.0->torchquantum==0.1.0) (3.2.0)\n", - "Requirement already satisfied: msgpack>=0.5.2 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (1.0.3)\n", - "Requirement already satisfied: tabulate>=0.7.7 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (0.8.9)\n", - "Collecting msgpack-numpy>=0.4.4.2\n", - " Downloading msgpack_numpy-0.4.7.1-py2.py3-none-any.whl (6.7 kB)\n", - "Requirement already satisfied: pyzmq>=16 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (22.3.0)\n", - "Requirement already satisfied: termcolor>=1.1 in /usr/local/lib/python3.7/dist-packages (from tensorpack->torchpack>=0.3.0->torchquantum==0.1.0) (1.1.0)\n", - "Installing collected packages: msgpack-numpy, toml, tensorpack, ppft, pox, multimethod, loguru, fonttools, torchpack, pathos, matplotlib, torchquantum\n", - " Attempting uninstall: matplotlib\n", - " Found existing installation: matplotlib 3.2.2\n", - " Uninstalling matplotlib-3.2.2:\n", - " Successfully uninstalled matplotlib-3.2.2\n", - " Running setup.py develop for torchquantum\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "albumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\n", - "Successfully installed fonttools-4.29.1 loguru-0.6.0 matplotlib-3.5.1 msgpack-numpy-0.4.7.1 multimethod-1.7 pathos-0.2.8 pox-0.3.0 ppft-1.6.6.4 tensorpack-0.11 toml-0.10.2 torchpack-0.3.1 torchquantum-0.1.0\n" - ] - }, - { - "data": { - "application/vnd.colab-display-data+json": { - "pip_warning": { - "packages": [ - "matplotlib", - "mpl_toolkits" - ] - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "!pip install --editable ." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:20:36.374] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:20:36.398] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "18tqleq4O3cX" - }, - "source": [ - "Change PYTHONPATH and install other packages." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "d7ZPp7FikrZz", - "outputId": "9ee13348-41b4-4566-c079-5f2a56a308d8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "env: PYTHONPATH=.\n" - ] - } - ], - "source": [ - "%env PYTHONPATH=." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:23:07.068] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:23:07.129] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "rhsBhV23PD4g" - }, - "source": [ - "Run the following code to store a qiskit token. You can replace it with your own token from your IBMQ account if you like.\n", - "\n" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Iw9rQ6dcnrhe" - }, - "outputs": [], - "source": [ - "from qiskit import IBMQ\n", - "IBMQ.save_account('51a2a5d55d3e1d9683ab4f135fe6fbb84ecf3221765e19adb408699d43c6eaa238265059c3c2955ba59328634ffbd88ba14d5386c947d22eb9a826e40811d626', overwrite=True)" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:23:47.123] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:23:47.144] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Nvn9EkRH5fTs", - "outputId": "57c475a3-d0aa-431f-9f8c-35cc5ddce22e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting matplotlib==3.1.3\n", - " Downloading matplotlib-3.1.3-cp37-cp37m-manylinux1_x86_64.whl (13.1 MB)\n", - "\u001b[K |████████████████████████████████| 13.1 MB 6.1 MB/s \n", - "\u001b[?25hRequirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (2.8.2)\n", - "Requirement already satisfied: numpy>=1.11 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (1.21.5)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (0.11.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (1.3.2)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (3.0.7)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib==3.1.3) (1.15.0)\n", - "Installing collected packages: matplotlib\n", - " Attempting uninstall: matplotlib\n", - " Found existing installation: matplotlib 3.5.1\n", - " Uninstalling matplotlib-3.5.1:\n", - " Successfully uninstalled matplotlib-3.5.1\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "torchquantum 0.1.0 requires matplotlib>=3.3.2, but you have matplotlib 3.1.3 which is incompatible.\n", - "albumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\n", - "Successfully installed matplotlib-3.1.3\n" - ] - }, - { - "data": { - "application/vnd.colab-display-data+json": { - "pip_warning": { - "packages": [ - "matplotlib", - "mpl_toolkits" - ] - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "!pip install matplotlib==3.1.3" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "sTwecaw_YyCX", - "outputId": "964c52c7-41ea-4443-e831-f6084cba2cf1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "aerbackend.py example2 example4 example6 README.md\n", - "example1 example3 example5 example7\n" - ] - } - ], - "source": [ - "!ls artifact" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:25:26.498] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:25:26.522] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "SNWF7ZlbVwVZ" - }, - "outputs": [], - "source": [ - "!cp artifact/aerbackend.py ../../usr/local/lib/python3.7/dist-packages/qiskit/providers/aer/backends/ -r" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "N5acspJ8G1n3", - "outputId": "f5b55e0a-71ca-44fa-dff3-fdc5b9490249" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - " WARNING: The qiskit parameterization bug is not fixed!\n", - "\n", - "run python fix_qiskit_parameterization.py to fix it!\n" - ] - } - ], - "source": [ - "import torch\n", - "import torch.nn.functional as F\n", - "import torch.optim as optim\n", - "import numpy as np\n", - "\n", - "import torchquantum as tq\n", - "import torchquantum.functional as tqf\n", - "from torchquantum.layers import SethLayer0\n", - "\n", - "from torchquantum.datasets import MNIST\n", - "from torch.optim.lr_scheduler import CosineAnnealingLR" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:26:56.630] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:26:56.653] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "QiOV-xIGKXVK" - }, - "source": [ - "### Build a quantum model\n", - "Our 4-qubit quantum model contains an encoder that can encode a 4x4 image to quantum state; a quantum layer RZZ+RY+RZZ+RY, 16 parameters in total; and PauliZ measure on each qubit." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "iBnWI5yqKfMB" - }, - "outputs": [], - "source": [ - "class QFCModel(tq.QuantumModule):\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.n_wires = 4\n", - " self.q_device = tq.QuantumDevice(n_wires=self.n_wires)\n", - " self.encoder = tq.GeneralEncoder(\n", - " tq.encoder_op_list_name_dict['4x4_ryzxy'])\n", - "\n", - " self.arch = {'n_wires': self.n_wires, 'n_blocks': 2, 'n_layers_per_block': 2}\n", - " self.q_layer = SethLayer0(self.arch)\n", - "\n", - " self.measure = tq.MeasureAll(tq.PauliZ)\n", - "\n", - " def forward(self, x, use_qiskit=False):\n", - " bsz = x.shape[0]\n", - " x = F.avg_pool2d(x, 6).view(bsz, 16)\n", - "\n", - " if use_qiskit:\n", - " x = self.qiskit_processor.process_parameterized(\n", - " self.q_device, self.encoder, self.q_layer, self.measure, x)\n", - " else:\n", - " self.encoder(self.q_device, x)\n", - " self.q_layer(self.q_device)\n", - " x = self.measure(self.q_device)\n", - "\n", - " x = x.reshape(bsz, 4)\n", - "\n", - " return x" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:27:37.407] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:27:37.431] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "EtE-1nRK70hY" - }, - "source": [ - "### Build the function of parameters shift rules\n", - "\n", - "The function can shift the parameters and calculate the gradients to the expectation value of each measure for each parameter. It returns both the expectaion values and the gradient for each parameter." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "eo91nL5s6IG4" - }, - "outputs": [], - "source": [ - "def shift_and_run(model, inputs, use_qiskit=False):\n", - " param_list = []\n", - " for param in model.parameters():\n", - " param_list.append(param)\n", - " grad_list = []\n", - " for param in param_list:\n", - " param.copy_(param + np.pi * 0.5)\n", - " out1 = model(inputs, use_qiskit)\n", - " param.copy_(param - np.pi)\n", - " out2 = model(inputs, use_qiskit)\n", - " param.copy_(param + np.pi * 0.5)\n", - " grad = 0.5 * (out1 - out2)\n", - " grad_list.append(grad)\n", - " return model(inputs, use_qiskit), grad_list" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:31:06.752] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:31:06.779] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "LpxOsZrRLUal" - }, - "source": [ - "Set whether using gpu, using cuda, number of epochs, optimizer and scheduler. Initialize the model and the MNIST-36 classification dataset." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 523, - "referenced_widgets": [ - "7912b116e746423eb09337b8779e4596", - "e4aee1dc9cc4422b9a46fd7c3b891c1e", - "a3dd57b01cee4ea4ad42ea50f0fec7e2", - "db515dafb0264e86b3eebbd95815c0f5", - "aaf91412563844d79b52c39c0f1c9a27", - "2cdf641f3e0c473f8292e25be238b775", - "ea68f1055083478f8028ef9f77528ecc", - "0a94560cb838462aa3ab371dff9633ee", - "9d65737db632488091db32e72e81713a", - "9fba1c7cbfef499994fa87ec83e38f4f", - "17dba6206cf04713a4d4fb8e50c251f8", - "474d5db7730a4e6196a596f965ff9eea", - "f156918126d748df8842ddc3a5cfc019", - "29077ee63ae8400fba43d953ce90088e", - "8903c72842294a48afafa28eace2f592", - "b7612723e13e4beca932f61cc64c6de9", - "119658777c3b46df83d0f51e9feafa66", - "134055d175fd4c6e8abb65da74b5cdc0", - "35c6f2a26f4145fbaf7d477565eb4c5c", - "4fe76f9ccfa74ccead52eb188e158c8c", - "7c58305314b9464a917f8f63deb86257", - "6ac0e78521d94dc0b790056bd42f686f", - "d2898cd0ae4741efa2e3ac708a76a091", - "f2a0be6a6c2a42dabc70d15392683334", - "8ecb7c40807647e7ab0e8e0d303e1f71", - "fc39778dcba04ad1b01a445a2ed7d8d2", - "ba9d7af431ef4e52929ffdcf8e0920d6", - "518fea7751344948995ccb701e8f3798", - "0642204f7afe4befaed2577fb23684ce", - "a2380893f25145d8a12a8118ad5c3e9c", - "5c75c06d1dfa4f22beb47df79634efc5", - "4d9264aa3f614c9ea59b049cf83e415f", - "ecb2185981e34dd789f85363bde70775", - "abc5126f11974c92978b7e6ef2802580", - "8c237190ce50450ea763296da6abefb1", - "9e08a5e3ab62449f9420965eb7bbfb7b", - "fb441059487e4cbeaa5c2113606abb0f", - "8bc37933515e4535b4edba3c3a348325", - "224d25aefd124bd3aaae61f169641944", - "7f85ee98f7a14211978e011634716c9f", - "04571b0b33fe4cea82770be70b59f464", - "78f0cd3a0fc247d6b1b9d49dc838a48a", - "222814e1aa664b15be06eda0e1c011dc", - "ee2880bc14a94f5bba5b767d9035da93" - ] - }, - "id": "cmzcsyaCLZf_", - "outputId": "be56e43b-fb3d-4987-f2c5-a1f9d12209c6" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7912b116e746423eb09337b8779e4596", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/9912422 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import matplotlib\n", - "\n", - "grads_bp = np.array(grads_bp)\n", - "grads_ps = np.array(grads_ps)\n", - "\n", - "n_steps = grads_bp.shape[0]\n", - "n_params = grads_bp.shape[1]\n", - "\n", - "fig, ax_list = plt.subplots(n_params, 1, sharex=True, figsize=(15, 2 * n_params))\n", - "\n", - "for i, ax in enumerate(ax_list):\n", - " ax.plot(grads_bp[:, i], c=\"#1f77b4\", label=\"back propagation\")\n", - " ax.scatter(range(n_steps), grads_ps[:, i], c=\"#ff7f0e\", marker=\"^\", label=\"parameters shift\")\n", - " ax.set_ylabel(\"grad of param{0}\".format(i))\n", - " ax.set_xlabel(\"Step\")\n", - " ax.legend()\n", - " ax.axhline(color='black', lw=0.5)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:38:27.033] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:38:27.052] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "hlVjpUb9fP6O" - }, - "source": [ - "## A simple 2 qubit model for a simple 2 classification task\n", - "\n", - "Firstly we create a dataset. The dataset is a simple 2 classification dataset from [Jiang et al. (2020)](https://arxiv.org/pdf/2006.14815.pdf).\n", - "\n", - "
\n", - "\"conv-full-layer\"\n", - "
" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Q7blg45uTAWC" - }, - "outputs": [], - "source": [ - "from torchpack.datasets.dataset import Dataset\n", - "\n", - "class Classification2Dataset(torch.utils.data.Dataset):\n", - " def __init__(self, num=11):\n", - " self.data = []\n", - " self.target = []\n", - " sum0 = 0\n", - " sum1 = 0\n", - " for x in np.linspace(0, 1, num=num):\n", - " for y in np.linspace(0, 1, num=num):\n", - " self.data.append(torch.tensor([x, y]))\n", - " if (x**2 + y**2 <= 0.55**2 or (x-1)**2 + (y-1)**2 <= 0.55**2):\n", - " self.target.append(1)\n", - " sum1 = sum1 + 1\n", - " else:\n", - " self.target.append(0)\n", - " sum0 = sum0 + 1\n", - " print(self.target[-num:])\n", - "\n", - " def __getitem__(self, idx):\n", - " return {'data': self.data[idx], 'target': self.target[idx]}\n", - "\n", - " def __len__(self):\n", - " return len(self.target) - 1\n", - "\n", - "class Simple2Class(Dataset):\n", - " def __init__(self):\n", - " train_dataset = Classification2Dataset()\n", - " valid_dataset = Classification2Dataset(num=10)\n", - " datasets = {'train': train_dataset, 'valid': valid_dataset, 'test': valid_dataset}\n", - " super().__init__(datasets)\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:40:47.160] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:40:47.185] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "J1hTBSA1JrUu" - }, - "source": [ - "Then we create our quantum circuit\n", - "
\n", - "\"conv-full-layer\"\n", - "
\n", - "\n", - "The circuit only contains three trainable parameters. When executing the model, we firstly transform the input (x, y) to the phase $\\arcsin(\\sqrt{x+y-xy})$ and feed the phase to an RY gate. This is the encoding. After the ansatz, the 2 expectation values from 2 measures are the circuit outputs. Outside the circuit, we add a logsoftmax function to the output and get the predictions of each class." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "20akixa4fPIx" - }, - "outputs": [], - "source": [ - "class Q2Model(tq.QuantumModule):\n", - " class Ansatz(tq.QuantumModule):\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.n_wires = 2\n", - " self.op1 = tq.RZ(has_params=True, trainable=True)\n", - " self.op2 = tq.RY(has_params=True, trainable=True)\n", - " self.op3 = tq.RY(has_params=True, trainable=True)\n", - " self.op4 = tq.CNOT(has_params=False, trainable=False)\n", - " \n", - " def forward(self, q_device: tq.QuantumDevice):\n", - " self.q_device = q_device\n", - " self.op1(self.q_device, wires=0)\n", - " self.op2(self.q_device, wires=1)\n", - " self.op3(self.q_device, wires=0)\n", - " self.op4(self.q_device, wires=[0, 1])\n", - "\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.n_wires = 2\n", - " self.q_device = tq.QuantumDevice(n_wires=self.n_wires)\n", - " self.encoder = tq.GeneralEncoder([{'input_idx': [0], 'func': 'ry', 'wires': [0]}])\n", - "\n", - " self.ansatz = self.Ansatz()\n", - "\n", - " self.measure = tq.MeasureAll(tq.PauliZ)\n", - "\n", - " def forward(self, x, use_qiskit=False):\n", - " bsz = x.shape[0]\n", - " data = 2 * torch.arcsin(torch.sqrt(x[:, 0] + x[:, 1] - 2 * x[:, 0] * x[:, 1])).reshape(bsz, 1)\n", - "\n", - " if use_qiskit:\n", - " data = self.qiskit_processor.process_parameterized(\n", - " self.q_device, self.encoder, self.ansatz, self.measure, data)\n", - " else:\n", - " self.encoder(self.q_device, data)\n", - " self.ansatz(self.q_device)\n", - " data = self.measure(self.q_device)\n", - "\n", - " data = data.reshape(bsz, 2)\n", - "\n", - " return data\n", - "\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:41:27.189] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:41:27.213] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "FA_uGgwPgObj" - }, - "source": [ - "Load the dataset." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (13) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "A2hYxOfefXTn", - "outputId": "932a6f31-7e0c-4997-cbd2-60a18edb530b" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n", - "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 1, 0, 0, 0, 0, 0, 0]\n", - "[1, 1, 1, 0, 0, 0, 0, 0, 0, 0]\n", - "[0, 0, 0, 0, 0, 0, 0, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 0, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n", - "[0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " cpuset_checked))\n" - ] - } - ], - "source": [ - "dataset = Simple2Class()\n", - "dataflow = dict()\n", - "for split in dataset:\n", - " sampler = torch.utils.data.RandomSampler(dataset[split])\n", - " dataflow[split] = torch.utils.data.DataLoader(\n", - " dataset[split],\n", - " batch_size=10,\n", - " sampler=sampler,\n", - " num_workers=8,\n", - " pin_memory=True)" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:43:07.037] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:43:07.057] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "-_KlYIsqgQbL" - }, - "source": [ - "Define train and valid function. The model is a 2-qubit model so there is a slightly difference to the process of the circuit output." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "TqvdF76rf4XL" - }, - "outputs": [], - "source": [ - "def train_2qubit(dataflow, model, device, optimizer, qiskit=False, input_name = 'data', target_name = 'target'):\n", - " for feed_dict in dataflow['train']:\n", - " inputs = feed_dict[input_name].to(device)\n", - " targets = feed_dict[target_name].to(device)\n", - "\n", - " with torch.no_grad():\n", - " outputs, grad_list = shift_and_run(model, inputs, use_qiskit=qiskit)\n", - " outputs.requires_grad=True\n", - " prediction = F.log_softmax(outputs, dim=1)\n", - " loss = F.nll_loss(prediction, targets)\n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " for i, param in enumerate(model.parameters()):\n", - " param.grad = torch.sum(grad_list[i] * outputs.grad).to(dtype=torch.float32, device=param.device).view(param.shape)\n", - " optimizer.step()\n", - " print(f\"loss: {loss.item()}\", end='\\r')\n", - "\n", - "\n", - "def valid_test_2qubit(dataflow, split, model, device, qiskit=False, input_name = 'data', target_name = 'target'):\n", - " target_all = []\n", - " output_all = []\n", - " with torch.no_grad():\n", - " for feed_dict in dataflow[split]:\n", - " inputs = feed_dict[input_name].to(device)\n", - " targets = feed_dict[target_name].to(device)\n", - "\n", - " outputs = model(inputs, use_qiskit=qiskit)\n", - " prediction = F.log_softmax(outputs, dim=1)\n", - "\n", - " target_all.append(targets)\n", - " output_all.append(prediction)\n", - " target_all = torch.cat(target_all, dim=0)\n", - " output_all = torch.cat(output_all, dim=0)\n", - "\n", - " _, indices = output_all.topk(1, dim=1)\n", - " masks = indices.eq(target_all.view(-1, 1).expand_as(indices))\n", - " size = target_all.shape[0]\n", - " corrects = masks.sum().item()\n", - " accuracy = corrects / size\n", - " loss = F.nll_loss(output_all, target_all).item()\n", - "\n", - " print(f\"{split} set accuracy: {accuracy}\")\n", - " print(f\"{split} set loss: {loss}\")\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:44:47.291] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:44:47.318] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "ycs5rJMNgoYh" - }, - "source": [ - "Train and valid the model on ibmq_quito. You need to import `QiskitProcessor` from `torchquantum.plugin` to create a processor that handles your access to real quantum computer. You can set whether use real quantum computer or qiskit's noise model, and the backend of your quantum computer. Call `model.set_qiskit_processor` to attach the processor to your model." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (None) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "background_save": true, - "base_uri": "https://localhost:8080/" - }, - "id": "wdMKCOaZft0E", - "outputId": "9aec13c7-5ed9-426e-94ee-11fe3d7dddf4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " cpuset_checked))\n", - "/usr/local/lib/python3.7/dist-packages/qiskit/circuit/quantumcircuit.py:933: DeprecationWarning: The QuantumCircuit.combine() method is being deprecated. Use the compose() method which is more flexible w.r.t circuit register compatibility.\n", - " return self.combine(rhs)\n", - "[2022-03-02 05:03:08.183] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 05:03:08.472] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (18) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:07:04.863] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:07:04.885] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (17) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:10:45.202] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:10:45.220] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:16:00.892] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:16:00.912] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:19:42.755] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:19:42.778] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (14) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:23:10.114] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:23:10.137] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (14) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:24:51.741] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:24:51.767] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (13) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:28:21.188] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:28:21.242] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:32:01.063] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:32:01.088] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:35:51.696] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:35:51.770] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:45:21.062] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:45:21.132] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 09:55:17.874] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 09:55:17.901] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 10:05:40.990] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 10:05:41.011] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 11:46:53.672] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 11:46:53.694] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 11:56:33.439] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 11:56:33.463] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 12:07:13.294] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 12:07:13.314] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (14) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 12:16:33.349] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 12:16:33.373] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (13) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 12:20:43.430] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 12:20:43.499] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 12:30:34.169] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 12:30:34.252] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 12:36:42.971] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 12:36:42.991] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 12:40:23.251] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 12:40:23.276] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 13:08:24.755] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 13:08:24.779] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 13:54:44.675] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 13:54:44.696] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 13:58:23.983] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 13:58:24.006] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (13) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:09:04.009] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:09:04.079] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:12:44.205] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:12:44.226] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:16:23.556] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:16:23.577] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:20:04.063] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:20:04.083] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:23:44.058] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:23:44.151] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:28:15.393] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:28:15.414] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:32:06.613] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:32:06.637] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:42:25.762] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:42:25.783] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (15) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:52:56.361] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:52:56.387] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (17) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 14:53:56.366] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 14:53:56.393] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:05:35.743] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:05:35.783] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (19) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:15:45.472] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:15:45.492] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:17:24.834] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:17:24.852] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (19) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:27:16.382] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:27:16.405] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (21) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:29:50.433] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:29:50.458] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (21) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:31:56.050] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:31:56.072] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:34:26.703] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:34:26.724] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:36:45.595] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:36:45.618] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:39:15.354] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:39:15.378] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:48:56.005] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:48:56.029] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (21) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 15:50:45.708] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 15:50:45.727] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (20) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:00:26.978] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:00:27.000] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (21) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:02:36.243] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:02:36.269] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (20) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:03:16.094] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:03:16.115] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:05:05.797] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:05:05.822] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (19) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:06:56.090] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:06:56.113] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:16:36.369] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:16:36.393] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (23) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:18:26.440] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:18:26.463] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:20:26.218] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:20:26.243] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (22) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:27:16.190] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:27:16.210] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (21) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:29:16.272] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:29:16.334] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (20) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:39:15.345] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:39:15.370] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (18) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:41:15.622] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:41:15.646] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:43:36.314] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:43:36.340] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:46:06.862] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:46:06.887] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:48:25.597] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:48:25.616] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (15) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 16:50:56.397] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 16:50:56.425] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (14) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:02:46.871] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:02:46.896] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (18) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:13:13.351] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:13:13.373] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:13:58.825] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:13:58.849] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:15:47.488] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:15:47.510] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (17) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:17:15.990] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:17:16.099] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:27:06.069] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:27:06.092] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:37:17.048] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:37:17.073] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:39:06.751] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:39:06.776] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:48:56.162] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:48:56.180] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:51:16.778] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:51:16.803] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:53:46.496] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:53:46.519] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:56:06.057] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:56:06.081] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 17:58:36.793] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 17:58:36.819] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (16) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:02:55.920] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:02:55.945] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:04:46.666] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:04:46.690] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (13) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:05:26.258] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:05:26.308] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (13) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:06:07.303] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:06:07.331] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:07:44.036] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:07:44.058] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:09:19.642] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:09:19.667] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:18:56.005] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:18:56.026] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:28:46.057] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:28:46.083] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:38:27.342] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:38:27.410] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:48:35.734] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:48:35.756] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n", - "0.05\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " cpuset_checked))\n", - "[2022-03-02 18:51:06.781] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:51:06.812] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:53:27.365] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:53:27.445] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:55:46.501] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:55:46.526] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:58:16.855] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:58:16.883] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:58:56.647] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:58:56.674] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 18:59:49.658] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 18:59:49.680] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:03:20.134] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:03:20.161] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:04:56.306] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:04:56.332] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:05:36.655] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:05:36.681] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:09:06.636] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:09:06.657] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n", - "valid set accuracy: 0.9494949494949495\n", - "valid set loss: 0.47831726414734255\n", - "Epoch 2:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:09:46.487] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:09:46.519] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:12:16.753] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:12:16.773] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:15:15.180] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:15:15.210] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:17:36.772] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:17:36.817] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (12) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:20:36.374] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:20:36.398] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:23:07.068] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:23:07.129] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:23:47.123] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:23:47.144] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:25:26.498] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:25:26.522] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:26:56.630] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:26:56.653] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:27:37.407] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:27:37.431] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:31:06.752] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:31:06.779] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:33:37.382] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:33:37.403] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:35:57.615] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:35:57.640] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:38:27.033] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:38:27.052] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:40:47.160] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:40:47.185] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:41:27.189] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:41:27.213] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (13) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:43:07.037] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:43:07.057] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:44:47.291] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:44:47.318] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (None) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:45:26.740] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:45:26.761] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:48:57.187] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:48:57.214] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:49:36.542] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:49:36.565] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:52:26.689] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:52:26.780] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:54:56.648] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:54:56.675] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:57:16.345] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:57:16.369] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 19:59:36.692] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 19:59:36.713] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:03:46.903] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:03:46.974] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:04:37.384] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:04:37.409] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:05:28.159] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:05:28.183] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:06:07.325] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "loss: 0.566702274514434\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:06:07.548] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:09:37.298] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:09:37.331] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:10:17.646] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:10:17.672] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:12:41.411] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:12:41.437] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:15:06.674] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:15:06.700] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:17:26.494] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:17:26.517] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:19:47.699] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:19:47.810] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:20:27.033] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:20:27.050] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:21:06.326] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:21:06.385] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:24:51.052] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:24:51.098] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:25:37.601] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:25:37.627] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:28:07.233] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:28:07.259] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:30:27.964] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:30:27.988] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:32:46.987] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:32:47.014] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:35:17.957] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:35:17.979] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:37:37.626] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:37:37.650] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:38:23.240] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:38:23.261] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:41:58.185] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:41:58.206] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:44:27.284] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:44:27.310] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:46:47.400] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:46:47.422] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:49:18.053] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:49:18.079] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:51:58.016] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:51:58.112] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Job Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:52:37.781] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:52:37.801] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:53:17.565] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:53:17.589] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:56:47.625] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:56:47.644] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:57:27.651] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:57:27.747] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 20:58:07.759] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 20:58:07.783] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\rJob Status: job is being validated\rJob Status: job is queued (11) \rJob Status: job is queued (1) \rJob Status: job is actively running\rJob Status: job has successfully run\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[2022-03-02 21:02:36.724] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", - "[2022-03-02 21:02:36.746] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" - ] - } - ], - "source": [ - "from torchquantum.plugin import QiskitProcessor\n", - "model = Q2Model().to(device)\n", - "processor_real_qc = QiskitProcessor(use_real_qc=True, backend_name='ibmq_quito')\n", - "model.set_qiskit_processor(processor_real_qc)\n", - "\n", - "n_epochs = 5\n", - "optimizer = optim.Adam(model.parameters(), lr=5e-2, weight_decay=1e-4)\n", - "scheduler = CosineAnnealingLR(optimizer, T_max=n_epochs)\n", - "for epoch in range(1, n_epochs + 1):\n", - " # train\n", - " print(f\"Epoch {epoch}:\")\n", - " train_2qubit(dataflow, model, device, optimizer, qiskit=True)\n", - " print(optimizer.param_groups[0]['lr'])\n", - " # valid\n", - " valid_test_2qubit(dataflow, 'valid', model, device, qiskit=True)\n", - " scheduler.step()\n", - "# test\n", - "valid_test_2qubit(dataflow, 'test', model, device, qiskit=True)\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:45:26.740] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:45:26.761] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:48:57.187] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:48:57.214] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:49:36.542] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:49:36.565] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:52:26.689] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:52:26.780] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:54:56.648] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:54:56.675] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:57:16.345] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:57:16.369] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 19:59:36.692] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 19:59:36.713] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:03:46.903] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:03:46.974] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:04:37.384] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:04:37.409] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:05:28.159] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:05:28.183] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:06:07.325] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 0.566702274514434\r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:06:07.548] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:09:37.298] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:09:37.331] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:10:17.646] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:10:17.672] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:12:41.411] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:12:41.437] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:15:06.674] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:15:06.700] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:17:26.494] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:17:26.517] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:19:47.699] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:19:47.810] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:20:27.033] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:20:27.050] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:21:06.326] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:21:06.385] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:24:51.052] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:24:51.098] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:25:37.601] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:25:37.627] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:28:07.233] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:28:07.259] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:30:27.964] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:30:27.988] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:32:46.987] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:32:47.014] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:35:17.957] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:35:17.979] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:37:37.626] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:37:37.650] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:38:23.240] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:38:23.261] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:41:58.185] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:41:58.206] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:44:27.284] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:44:27.310] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:46:47.400] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:46:47.422] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:49:18.053] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:49:18.079] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:51:58.016] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:51:58.112] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:52:37.781] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:52:37.801] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:53:17.565] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:53:17.589] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:56:47.625] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:56:47.644] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:57:27.651] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:57:27.747] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 20:58:07.759] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 20:58:07.783] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "Job Status: job is being validated\r", + "Job Status: job is queued (11) \r", + "Job Status: job is queued (1) \r", + "Job Status: job is actively running\r", + "Job Status: job has successfully run\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2022-03-02 21:02:36.724] Before transpile: {'depth': 5, 'size': 7, 'width': 4, 'n_single_gates': 4, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'ry': 3, 'rz': 1, 'cx': 1, 'measure': 2}}\n", + "[2022-03-02 21:02:36.746] After transpile: {'depth': 9, 'size': 14, 'width': 7, 'n_single_gates': 11, 'n_two_gates': 1, 'n_three_more_gates': 0, 'n_gates_dict': {'sx': 5, 'rz': 6, 'cx': 1, 'measure': 2}}\n" + ] } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "collapsed_sections": [ - "pfwd2SNaOA4z" + ], + "source": [ + "from torchquantum.plugin import QiskitProcessor\n", + "model = Q2Model().to(device)\n", + "processor_real_qc = QiskitProcessor(use_real_qc=True, backend_name='ibmq_quito')\n", + "model.set_qiskit_processor(processor_real_qc)\n", + "\n", + "n_epochs = 5\n", + "optimizer = optim.Adam(model.parameters(), lr=5e-2, weight_decay=1e-4)\n", + "scheduler = CosineAnnealingLR(optimizer, T_max=n_epochs)\n", + "for epoch in range(1, n_epochs + 1):\n", + " # train\n", + " print(f\"Epoch {epoch}:\")\n", + " train_2qubit(dataflow, model, device, optimizer, qiskit=True)\n", + " print(optimizer.param_groups[0]['lr'])\n", + " # valid\n", + " valid_test_2qubit(dataflow, 'valid', model, device, qiskit=True)\n", + " scheduler.step()\n", + "# test\n", + "valid_test_2qubit(dataflow, 'test', model, device, qiskit=True)\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "pfwd2SNaOA4z" + ], + "name": "Parameters Shift Training", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "04571b0b33fe4cea82770be70b59f464": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0642204f7afe4befaed2577fb23684ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a94560cb838462aa3ab371dff9633ee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "119658777c3b46df83d0f51e9feafa66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "134055d175fd4c6e8abb65da74b5cdc0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "17dba6206cf04713a4d4fb8e50c251f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "222814e1aa664b15be06eda0e1c011dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "224d25aefd124bd3aaae61f169641944": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "29077ee63ae8400fba43d953ce90088e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35c6f2a26f4145fbaf7d477565eb4c5c", + "max": 28881, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4fe76f9ccfa74ccead52eb188e158c8c", + "value": 28881 + } + }, + "2cdf641f3e0c473f8292e25be238b775": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35c6f2a26f4145fbaf7d477565eb4c5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "474d5db7730a4e6196a596f965ff9eea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f156918126d748df8842ddc3a5cfc019", + "IPY_MODEL_29077ee63ae8400fba43d953ce90088e", + "IPY_MODEL_8903c72842294a48afafa28eace2f592" ], - "name": "Parameters Shift Training", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "04571b0b33fe4cea82770be70b59f464": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0642204f7afe4befaed2577fb23684ce": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "0a94560cb838462aa3ab371dff9633ee": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "119658777c3b46df83d0f51e9feafa66": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "134055d175fd4c6e8abb65da74b5cdc0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "17dba6206cf04713a4d4fb8e50c251f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "222814e1aa664b15be06eda0e1c011dc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "224d25aefd124bd3aaae61f169641944": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "29077ee63ae8400fba43d953ce90088e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_35c6f2a26f4145fbaf7d477565eb4c5c", - "max": 28881, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_4fe76f9ccfa74ccead52eb188e158c8c", - "value": 28881 - } - }, - "2cdf641f3e0c473f8292e25be238b775": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "35c6f2a26f4145fbaf7d477565eb4c5c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "474d5db7730a4e6196a596f965ff9eea": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f156918126d748df8842ddc3a5cfc019", - "IPY_MODEL_29077ee63ae8400fba43d953ce90088e", - "IPY_MODEL_8903c72842294a48afafa28eace2f592" - ], - "layout": "IPY_MODEL_b7612723e13e4beca932f61cc64c6de9" - } - }, - "4d9264aa3f614c9ea59b049cf83e415f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "4fe76f9ccfa74ccead52eb188e158c8c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "518fea7751344948995ccb701e8f3798": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5c75c06d1dfa4f22beb47df79634efc5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "6ac0e78521d94dc0b790056bd42f686f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "78f0cd3a0fc247d6b1b9d49dc838a48a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "7912b116e746423eb09337b8779e4596": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e4aee1dc9cc4422b9a46fd7c3b891c1e", - "IPY_MODEL_a3dd57b01cee4ea4ad42ea50f0fec7e2", - "IPY_MODEL_db515dafb0264e86b3eebbd95815c0f5" - ], - "layout": "IPY_MODEL_aaf91412563844d79b52c39c0f1c9a27" - } - }, - "7c58305314b9464a917f8f63deb86257": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "7f85ee98f7a14211978e011634716c9f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "8903c72842294a48afafa28eace2f592": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7c58305314b9464a917f8f63deb86257", - "placeholder": "​", - "style": "IPY_MODEL_6ac0e78521d94dc0b790056bd42f686f", - "value": " 29696/? [00:00<00:00, 759619.51it/s]" - } - }, - "8bc37933515e4535b4edba3c3a348325": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "8c237190ce50450ea763296da6abefb1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_224d25aefd124bd3aaae61f169641944", - "placeholder": "​", - "style": "IPY_MODEL_7f85ee98f7a14211978e011634716c9f", - "value": "" - } - }, - "8ecb7c40807647e7ab0e8e0d303e1f71": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_a2380893f25145d8a12a8118ad5c3e9c", - "max": 1648877, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_5c75c06d1dfa4f22beb47df79634efc5", - "value": 1648877 - } - }, - "9d65737db632488091db32e72e81713a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9e08a5e3ab62449f9420965eb7bbfb7b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_04571b0b33fe4cea82770be70b59f464", - "max": 4542, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_78f0cd3a0fc247d6b1b9d49dc838a48a", - "value": 4542 - } - }, - "9fba1c7cbfef499994fa87ec83e38f4f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a2380893f25145d8a12a8118ad5c3e9c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a3dd57b01cee4ea4ad42ea50f0fec7e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_0a94560cb838462aa3ab371dff9633ee", - "max": 9912422, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_9d65737db632488091db32e72e81713a", - "value": 9912422 - } - }, - "aaf91412563844d79b52c39c0f1c9a27": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "abc5126f11974c92978b7e6ef2802580": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_8c237190ce50450ea763296da6abefb1", - "IPY_MODEL_9e08a5e3ab62449f9420965eb7bbfb7b", - "IPY_MODEL_fb441059487e4cbeaa5c2113606abb0f" - ], - "layout": "IPY_MODEL_8bc37933515e4535b4edba3c3a348325" - } - }, - "b7612723e13e4beca932f61cc64c6de9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "ba9d7af431ef4e52929ffdcf8e0920d6": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d2898cd0ae4741efa2e3ac708a76a091": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_f2a0be6a6c2a42dabc70d15392683334", - "IPY_MODEL_8ecb7c40807647e7ab0e8e0d303e1f71", - "IPY_MODEL_fc39778dcba04ad1b01a445a2ed7d8d2" - ], - "layout": "IPY_MODEL_ba9d7af431ef4e52929ffdcf8e0920d6" - } - }, - "db515dafb0264e86b3eebbd95815c0f5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_9fba1c7cbfef499994fa87ec83e38f4f", - "placeholder": "​", - "style": "IPY_MODEL_17dba6206cf04713a4d4fb8e50c251f8", - "value": " 9913344/? [00:00<00:00, 34693507.65it/s]" - } - }, - "e4aee1dc9cc4422b9a46fd7c3b891c1e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_2cdf641f3e0c473f8292e25be238b775", - "placeholder": "​", - "style": "IPY_MODEL_ea68f1055083478f8028ef9f77528ecc", - "value": "" - } - }, - "ea68f1055083478f8028ef9f77528ecc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "ecb2185981e34dd789f85363bde70775": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "ee2880bc14a94f5bba5b767d9035da93": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "f156918126d748df8842ddc3a5cfc019": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_119658777c3b46df83d0f51e9feafa66", - "placeholder": "​", - "style": "IPY_MODEL_134055d175fd4c6e8abb65da74b5cdc0", - "value": "" - } - }, - "f2a0be6a6c2a42dabc70d15392683334": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_518fea7751344948995ccb701e8f3798", - "placeholder": "​", - "style": "IPY_MODEL_0642204f7afe4befaed2577fb23684ce", - "value": "" - } - }, - "fb441059487e4cbeaa5c2113606abb0f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_222814e1aa664b15be06eda0e1c011dc", - "placeholder": "​", - "style": "IPY_MODEL_ee2880bc14a94f5bba5b767d9035da93", - "value": " 5120/? [00:00<00:00, 131436.21it/s]" - } - }, - "fc39778dcba04ad1b01a445a2ed7d8d2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_4d9264aa3f614c9ea59b049cf83e415f", - "placeholder": "​", - "style": "IPY_MODEL_ecb2185981e34dd789f85363bde70775", - "value": " 1649664/? [00:00<00:00, 3870040.90it/s]" - } - } - } + "layout": "IPY_MODEL_b7612723e13e4beca932f61cc64c6de9" + } + }, + "4d9264aa3f614c9ea59b049cf83e415f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4fe76f9ccfa74ccead52eb188e158c8c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "518fea7751344948995ccb701e8f3798": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c75c06d1dfa4f22beb47df79634efc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6ac0e78521d94dc0b790056bd42f686f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "78f0cd3a0fc247d6b1b9d49dc838a48a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7912b116e746423eb09337b8779e4596": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4aee1dc9cc4422b9a46fd7c3b891c1e", + "IPY_MODEL_a3dd57b01cee4ea4ad42ea50f0fec7e2", + "IPY_MODEL_db515dafb0264e86b3eebbd95815c0f5" + ], + "layout": "IPY_MODEL_aaf91412563844d79b52c39c0f1c9a27" + } + }, + "7c58305314b9464a917f8f63deb86257": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7f85ee98f7a14211978e011634716c9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8903c72842294a48afafa28eace2f592": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7c58305314b9464a917f8f63deb86257", + "placeholder": "​", + "style": "IPY_MODEL_6ac0e78521d94dc0b790056bd42f686f", + "value": " 29696/? [00:00<00:00, 759619.51it/s]" + } + }, + "8bc37933515e4535b4edba3c3a348325": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8c237190ce50450ea763296da6abefb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_224d25aefd124bd3aaae61f169641944", + "placeholder": "​", + "style": "IPY_MODEL_7f85ee98f7a14211978e011634716c9f", + "value": "" + } + }, + "8ecb7c40807647e7ab0e8e0d303e1f71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2380893f25145d8a12a8118ad5c3e9c", + "max": 1648877, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5c75c06d1dfa4f22beb47df79634efc5", + "value": 1648877 + } + }, + "9d65737db632488091db32e72e81713a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9e08a5e3ab62449f9420965eb7bbfb7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04571b0b33fe4cea82770be70b59f464", + "max": 4542, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_78f0cd3a0fc247d6b1b9d49dc838a48a", + "value": 4542 + } + }, + "9fba1c7cbfef499994fa87ec83e38f4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a2380893f25145d8a12a8118ad5c3e9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3dd57b01cee4ea4ad42ea50f0fec7e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a94560cb838462aa3ab371dff9633ee", + "max": 9912422, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9d65737db632488091db32e72e81713a", + "value": 9912422 + } + }, + "aaf91412563844d79b52c39c0f1c9a27": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "abc5126f11974c92978b7e6ef2802580": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8c237190ce50450ea763296da6abefb1", + "IPY_MODEL_9e08a5e3ab62449f9420965eb7bbfb7b", + "IPY_MODEL_fb441059487e4cbeaa5c2113606abb0f" + ], + "layout": "IPY_MODEL_8bc37933515e4535b4edba3c3a348325" + } + }, + "b7612723e13e4beca932f61cc64c6de9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba9d7af431ef4e52929ffdcf8e0920d6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2898cd0ae4741efa2e3ac708a76a091": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f2a0be6a6c2a42dabc70d15392683334", + "IPY_MODEL_8ecb7c40807647e7ab0e8e0d303e1f71", + "IPY_MODEL_fc39778dcba04ad1b01a445a2ed7d8d2" + ], + "layout": "IPY_MODEL_ba9d7af431ef4e52929ffdcf8e0920d6" + } + }, + "db515dafb0264e86b3eebbd95815c0f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9fba1c7cbfef499994fa87ec83e38f4f", + "placeholder": "​", + "style": "IPY_MODEL_17dba6206cf04713a4d4fb8e50c251f8", + "value": " 9913344/? [00:00<00:00, 34693507.65it/s]" + } + }, + "e4aee1dc9cc4422b9a46fd7c3b891c1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2cdf641f3e0c473f8292e25be238b775", + "placeholder": "​", + "style": "IPY_MODEL_ea68f1055083478f8028ef9f77528ecc", + "value": "" + } + }, + "ea68f1055083478f8028ef9f77528ecc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ecb2185981e34dd789f85363bde70775": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee2880bc14a94f5bba5b767d9035da93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f156918126d748df8842ddc3a5cfc019": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_119658777c3b46df83d0f51e9feafa66", + "placeholder": "​", + "style": "IPY_MODEL_134055d175fd4c6e8abb65da74b5cdc0", + "value": "" + } + }, + "f2a0be6a6c2a42dabc70d15392683334": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_518fea7751344948995ccb701e8f3798", + "placeholder": "​", + "style": "IPY_MODEL_0642204f7afe4befaed2577fb23684ce", + "value": "" + } + }, + "fb441059487e4cbeaa5c2113606abb0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_222814e1aa664b15be06eda0e1c011dc", + "placeholder": "​", + "style": "IPY_MODEL_ee2880bc14a94f5bba5b767d9035da93", + "value": " 5120/? [00:00<00:00, 131436.21it/s]" + } + }, + "fc39778dcba04ad1b01a445a2ed7d8d2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d9264aa3f614c9ea59b049cf83e415f", + "placeholder": "​", + "style": "IPY_MODEL_ecb2185981e34dd789f85363bde70775", + "value": " 1649664/? [00:00<00:00, 3870040.90it/s]" + } } - }, - "nbformat": 4, - "nbformat_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 } From 566e1ffdac3bb87fc65f230fdd234d8a56477556 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 15 Sep 2023 07:48:17 -0400 Subject: [PATCH 017/106] =?UTF-8?q?structure=20reformatting=20of=20operati?= =?UTF-8?q?ons=20=E2=80=94=20passing=20tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/__init__.py | 1 - test/algorithm/test_hamiltonian.py | 234 +++-- test/functional/test_controlled_unitary.py | 749 ++++++++++++++-- test/functional/test_func_mat_exp.py | 74 +- test/hadamard_grad/test_hadamard_grad.py | 25 +- test/measurement/test_eval_observable.py | 8 +- .../test_expval_joint_sampling_grouping.py | 17 +- .../test_find_observable_groups.py | 47 +- test/measurement/test_measure.py | 1 - test/operator/test_ControlledU.py | 810 ++++++++++++++++-- test/operator/test_op_hamil_exp.py | 74 +- test/plugin/test_qiskit2tq_op_history.py | 4 +- test/plugin/test_qiskit_plugins.py | 11 +- test/static_mode_test.py | 2 +- test/utils.py | 1 + torchquantum/measurement/measurements.py | 21 +- torchquantum/operator/__init__.py | 5 +- torchquantum/operator/op_types.py | 12 + torchquantum/operator/operators.py | 238 ----- .../operator/standard_gates/__init__.py | 147 ++++ .../operator/{ => standard_gates}/ecr.py | 6 +- .../{ => standard_gates}/global_phase.py | 5 +- .../operator/{ => standard_gates}/hadamard.py | 7 +- .../operator/{ => standard_gates}/i.py | 5 +- .../operator/{ => standard_gates}/iswap.py | 5 +- .../operator/{ => standard_gates}/paulix.py | 11 +- .../operator/{ => standard_gates}/pauliy.py | 6 +- .../operator/{ => standard_gates}/pauliz.py | 7 +- .../{ => standard_gates}/phase_shift.py | 5 +- .../operator/{ => standard_gates}/qft.py | 5 +- .../{ => standard_gates}/qubit_unitary.py | 7 +- .../operator/{ => standard_gates}/r.py | 5 +- .../operator/{ => standard_gates}/reset.py | 5 +- .../operator/{ => standard_gates}/rot.py | 6 +- .../operator/{ => standard_gates}/rx.py | 7 +- .../operator/{ => standard_gates}/ry.py | 7 +- .../operator/{ => standard_gates}/rz.py | 9 +- .../operator/{ => standard_gates}/s.py | 8 +- .../{ => standard_gates}/single_excitation.py | 5 +- .../operator/{ => standard_gates}/swap.py | 7 +- .../operator/{ => standard_gates}/sx.py | 8 +- .../operator/{ => standard_gates}/t.py | 6 +- .../operator/{ => standard_gates}/toffoli.py | 10 +- .../{ => standard_gates}/trainable_unitary.py | 6 +- .../operator/{ => standard_gates}/u1.py | 6 +- .../operator/{ => standard_gates}/u2.py | 6 +- .../operator/{ => standard_gates}/u3.py | 13 +- .../{ => standard_gates}/xx_min_yy.py | 5 +- .../{ => standard_gates}/xx_plus_yy.py | 5 +- 49 files changed, 2067 insertions(+), 607 deletions(-) delete mode 100644 torchquantum/operator/operators.py create mode 100644 torchquantum/operator/standard_gates/__init__.py rename torchquantum/operator/{ => standard_gates}/ecr.py (76%) rename torchquantum/operator/{ => standard_gates}/global_phase.py (80%) rename torchquantum/operator/{ => standard_gates}/hadamard.py (89%) rename torchquantum/operator/{ => standard_gates}/i.py (86%) rename torchquantum/operator/{ => standard_gates}/iswap.py (81%) rename torchquantum/operator/{ => standard_gates}/paulix.py (91%) rename torchquantum/operator/{ => standard_gates}/pauliy.py (87%) rename torchquantum/operator/{ => standard_gates}/pauliz.py (89%) rename torchquantum/operator/{ => standard_gates}/phase_shift.py (79%) rename torchquantum/operator/{ => standard_gates}/qft.py (80%) rename torchquantum/operator/{ => standard_gates}/qubit_unitary.py (96%) rename torchquantum/operator/{ => standard_gates}/r.py (79%) rename torchquantum/operator/{ => standard_gates}/reset.py (78%) rename torchquantum/operator/{ => standard_gates}/rot.py (83%) rename torchquantum/operator/{ => standard_gates}/rx.py (86%) rename torchquantum/operator/{ => standard_gates}/ry.py (86%) rename torchquantum/operator/{ => standard_gates}/rz.py (89%) rename torchquantum/operator/{ => standard_gates}/s.py (90%) rename torchquantum/operator/{ => standard_gates}/single_excitation.py (80%) rename torchquantum/operator/{ => standard_gates}/swap.py (87%) rename torchquantum/operator/{ => standard_gates}/sx.py (89%) rename torchquantum/operator/{ => standard_gates}/t.py (85%) rename torchquantum/operator/{ => standard_gates}/toffoli.py (85%) rename torchquantum/operator/{ => standard_gates}/trainable_unitary.py (92%) rename torchquantum/operator/{ => standard_gates}/u1.py (84%) rename torchquantum/operator/{ => standard_gates}/u2.py (83%) rename torchquantum/operator/{ => standard_gates}/u3.py (86%) rename torchquantum/operator/{ => standard_gates}/xx_min_yy.py (79%) rename torchquantum/operator/{ => standard_gates}/xx_plus_yy.py (79%) diff --git a/test/__init__.py b/test/__init__.py index b2b23fa4..6dadfb34 100644 --- a/test/__init__.py +++ b/test/__init__.py @@ -23,4 +23,3 @@ """ from .utils import * - diff --git a/test/algorithm/test_hamiltonian.py b/test/algorithm/test_hamiltonian.py index 8f24c007..e5e8a60f 100644 --- a/test/algorithm/test_hamiltonian.py +++ b/test/algorithm/test_hamiltonian.py @@ -25,74 +25,208 @@ from torchquantum.algorithm import Hamiltonian import numpy as np + def test_hamiltonian(): coeffs = [1.0, 1.0] paulis = ["ZZ", "ZX"] hamil = Hamiltonian(coeffs, paulis) assert np.allclose( - hamil.get_matrix().cpu().detach().numpy(), + hamil.get_matrix().cpu().detach().numpy(), np.array( - [[ 1.+0.j, 1.+0.j, 0.+0.j, 0.+0.j], - [ 1.+0.j, -1.+0.j, 0.+0.j, 0.+0.j], - [ 0.+0.j, 0.+0.j, -1.+0.j, -1.+0.j], - [ 0.+0.j, 0.+0.j, -1.+0.j, 1.+0.j]])) - + [ + [1.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j], + [1.0 + 0.0j, -1.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j], + [0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j, -1.0 + 0.0j], + [0.0 + 0.0j, 0.0 + 0.0j, -1.0 + 0.0j, 1.0 + 0.0j], + ] + ), + ) coeffs = [0.6] paulis = ["XXZ"] hamil = Hamiltonian(coeffs, paulis) assert np.allclose( - hamil.get_matrix().cpu().detach().numpy(), + hamil.get_matrix().cpu().detach().numpy(), np.array( - [[ 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, - 0.6000+0.j, 0.0000+0.j], - [ 0.0000+0.j, -0.0000+0.j, 0.0000+0.j, -0.0000+0.j, 0.0000+0.j, -0.0000+0.j, - 0.0000+0.j, -0.6000+0.j], - [ 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.6000+0.j, 0.0000+0.j, - 0.0000+0.j, 0.0000+0.j], - [ 0.0000+0.j, -0.0000+0.j, 0.0000+0.j, -0.0000+0.j, 0.0000+0.j, -0.6000+0.j, - 0.0000+0.j, -0.0000+0.j], - [ 0.0000+0.j, 0.0000+0.j, 0.6000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, - 0.0000+0.j, 0.0000+0.j], - [ 0.0000+0.j, -0.0000+0.j, 0.0000+0.j, -0.6000+0.j, 0.0000+0.j, -0.0000+0.j, - 0.0000+0.j, -0.0000+0.j], - [ 0.6000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j, - 0.0000+0.j, 0.0000+0.j], - [ 0.0000+0.j, -0.6000+0.j, 0.0000+0.j, -0.0000+0.j, 0.0000+0.j, -0.0000+0.j, - 0.0000+0.j, -0.0000+0.j]])) - + [ + [ + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.6000 + 0.0j, + 0.0000 + 0.0j, + ], + [ + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.6000 + 0.0j, + ], + [ + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.6000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + ], + [ + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.6000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + ], + [ + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.6000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + ], + [ + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.6000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + ], + [ + 0.6000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + 0.0000 + 0.0j, + ], + [ + 0.0000 + 0.0j, + -0.6000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + 0.0000 + 0.0j, + -0.0000 + 0.0j, + ], + ] + ), + ) + hamil = Hamiltonian.from_file("test/algorithm/h2.txt") assert np.allclose( - hamil.matrix.cpu().detach().numpy(), + hamil.matrix.cpu().detach().numpy(), np.array( - [[-1.0636533 +0.j, 0. +0.j, 0. +0.j, - 0. +0.j, 0. +0.j, 0. +0.j, - 0.1809312 +0.j, 0. +0.j], - [ 0. +0.j, -1.0636533 +0.j, 0. +0.j, - 0. +0.j, 0. +0.j, 0. +0.j, - 0. +0.j, 0.1809312 +0.j], - [ 0. +0.j, 0. +0.j, -1.8369681 +0.j, - 0. +0.j, 0.1809312 +0.j, 0. +0.j, - 0. +0.j, 0. +0.j], - [ 0. +0.j, 0. +0.j, 0. +0.j, - -1.8369681 +0.j, 0. +0.j, 0.1809312 +0.j, - 0. +0.j, 0. +0.j], - [ 0. +0.j, 0. +0.j, 0.1809312 +0.j, - 0. +0.j, -0.24521835+0.j, 0. +0.j, - 0. +0.j, 0. +0.j], - [ 0. +0.j, 0. +0.j, 0. +0.j, - 0.1809312 +0.j, 0. +0.j, -0.24521835+0.j, - 0. +0.j, 0. +0.j], - [ 0.1809312 +0.j, 0. +0.j, 0. +0.j, - 0. +0.j, 0. +0.j, 0. +0.j, - -1.0636533 +0.j, 0. +0.j], - [ 0. +0.j, 0.1809312 +0.j, 0. +0.j, - 0. +0.j, 0. +0.j, 0. +0.j, - 0. +0.j, -1.0636533 +0.j]])) + [ + [ + -1.0636533 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.1809312 + 0.0j, + 0.0 + 0.0j, + ], + [ + 0.0 + 0.0j, + -1.0636533 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.1809312 + 0.0j, + ], + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + -1.8369681 + 0.0j, + 0.0 + 0.0j, + 0.1809312 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ], + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + -1.8369681 + 0.0j, + 0.0 + 0.0j, + 0.1809312 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ], + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.1809312 + 0.0j, + 0.0 + 0.0j, + -0.24521835 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ], + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.1809312 + 0.0j, + 0.0 + 0.0j, + -0.24521835 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ], + [ + 0.1809312 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + -1.0636533 + 0.0j, + 0.0 + 0.0j, + ], + [ + 0.0 + 0.0j, + 0.1809312 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + -1.0636533 + 0.0j, + ], + ] + ), + ) print("hamiltonian test passed!") -if __name__ == '__main__': + +if __name__ == "__main__": import pdb + pdb.set_trace() test_hamiltonian() diff --git a/test/functional/test_controlled_unitary.py b/test/functional/test_controlled_unitary.py index 0236d165..652ece59 100644 --- a/test/functional/test_controlled_unitary.py +++ b/test/functional/test_controlled_unitary.py @@ -26,6 +26,7 @@ from test.utils import check_all_close import numpy as np + def test_controlled_unitary(): state = tq.QuantumDevice(n_wires=2) # print(state) @@ -35,10 +36,16 @@ def test_controlled_unitary(): # ) state.paulix(0) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array([[0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j]]), + ) # print(state) state.controlled_unitary(params=tq.PauliX().matrix, c_wires=0, t_wires=1) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array([[0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j]]), + ) # gate(state) # print(state) @@ -57,9 +64,10 @@ def test_controlled_unitary(): state.paulix(0) rx_gate = tq.RX(has_params=True, init_params=0.25) state.controlled_unitary(params=rx_gate.matrix, c_wires=0, t_wires=1) - check_all_close(state.get_states_1d(), np.array([[0. +0.j , 0. +0.j , - 0.9921977+0.j , 0. -0.12467473j]])) - + check_all_close( + state.get_states_1d(), + np.array([[0.0 + 0.0j, 0.0 + 0.0j, 0.9921977 + 0.0j, 0.0 - 0.12467473j]]), + ) ############################ gate0 = tq.PauliX(n_wires=1, wires=0) @@ -71,33 +79,125 @@ def test_controlled_unitary(): state.paulix(0) state.paulix(1) state.controlled_unitary(params=tq.CNOT().matrix, c_wires=0, t_wires=[1, 2]) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################ state = tq.QuantumDevice(n_wires=5) state.paulix(0) state.paulix(1) state.paulix(4) - state.controlled_unitary(params=tq.CNOT().matrix, c_wires=1, t_wires=[[0, 2], [4, 3]]) - check_all_close(state.get_states_1d(), - np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) - + state.controlled_unitary( + params=tq.CNOT().matrix, c_wires=1, t_wires=[[0, 2], [4, 3]] + ) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) + ############################ state = tq.QuantumDevice(n_wires=5) state.paulix(0) state.paulix(1) state.paulix(2) state.paulix(3) - state.controlled_unitary(params=tq.Toffoli().matrix, c_wires=[0, 1], t_wires=[2, 3, 4]) - check_all_close(state.get_states_1d(), - np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) - + state.controlled_unitary( + params=tq.Toffoli().matrix, c_wires=[0, 1], t_wires=[2, 3, 4] + ) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) + ############################ state = tq.QuantumDevice(n_wires=9) state.paulix(0) @@ -108,72 +208,530 @@ def test_controlled_unitary(): state.paulix(6) state.paulix(7) - state.controlled_unitary(params=tq.Toffoli().matrix, c_wires=[0, 1, 2], t_wires=[[3, 4, 5], [6, 7, 8]]) - check_all_close(state.get_states_1d(), - np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + state.controlled_unitary( + params=tq.Toffoli().matrix, c_wires=[0, 1, 2], t_wires=[[3, 4, 5], [6, 7, 8]] + ) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################### gate_cx = tq.QubitUnitaryFast.from_controlled_operation( @@ -183,7 +741,24 @@ def test_controlled_unitary(): state.paulix(0) state.paulix(1) state.controlled_unitary(params=gate_cx.matrix, c_wires=0, t_wires=[1, 2]) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) + if __name__ == "__main__": test_controlled_unitary() diff --git a/test/functional/test_func_mat_exp.py b/test/functional/test_func_mat_exp.py index 1e0cbdb3..e2a2c293 100644 --- a/test/functional/test_func_mat_exp.py +++ b/test/functional/test_func_mat_exp.py @@ -31,34 +31,74 @@ def test_func_mat_exp(): qdev = tq.QuantumDevice(n_wires=3) qdev.reset_states(bsz=1) - qdev.matrix_exp(wires=[0], params=torch.tensor([[1., 2.], [3., 4.+1.j]])) + qdev.matrix_exp(wires=[0], params=torch.tensor([[1.0, 2.0], [3.0, 4.0 + 1.0j]])) assert np.allclose( - qdev.get_states_1d().cpu().detach().numpy(), + qdev.get_states_1d().cpu().detach().numpy(), np.array( - [[44.2796+23.9129j, 0.0000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j, - 85.5304+68.1896j, 0.0000+0.0000j, 0.0000+0.0000j, 0.0000+0.0000j]]) - ) - + [ + [ + 44.2796 + 23.9129j, + 0.0000 + 0.0000j, + 0.0000 + 0.0000j, + 0.0000 + 0.0000j, + 85.5304 + 68.1896j, + 0.0000 + 0.0000j, + 0.0000 + 0.0000j, + 0.0000 + 0.0000j, + ] + ] + ), + ) + qdev = tq.QuantumDevice(n_wires=3) qdev.reset_states(bsz=2) - qdev.matrix_exp(wires=[0, 2], params=torch.tensor([[1., 2., 2, 1], - [3., 4.+1.j, 2, 1], - [1., 2., 2, 1], - [3., 4.+1.j, 2, 1]]) - ) # type: ignore + qdev.matrix_exp( + wires=[0, 2], + params=torch.tensor( + [ + [1.0, 2.0, 2, 1], + [3.0, 4.0 + 1.0j, 2, 1], + [1.0, 2.0, 2, 1], + [3.0, 4.0 + 1.0j, 2, 1], + ] + ), + ) # type: ignore # print(qdev.get_states_1d().cpu().detach().numpy()) assert np.allclose( - qdev.get_states_1d().cpu().detach().numpy(), + qdev.get_states_1d().cpu().detach().numpy(), np.array( - [[483.20386+254.27155j, 747.27014+521.95013j, 0.+0.j, 0.+0.j, 482.2038+254.27151j, 747.27014+521.95013j, 0.+0.j, 0.+0.j], - [483.20386+254.27155j, 747.27014+521.95013j, 0.+0.j, 0.+0.j, 482.2038+254.27151j, 747.27014+521.95013j, 0.+0.j, 0.+0.j]] - )) + [ + [ + 483.20386 + 254.27155j, + 747.27014 + 521.95013j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 482.2038 + 254.27151j, + 747.27014 + 521.95013j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ], + [ + 483.20386 + 254.27155j, + 747.27014 + 521.95013j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 482.2038 + 254.27151j, + 747.27014 + 521.95013j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ], + ] + ), + ) + -if __name__ == '__main__': +if __name__ == "__main__": import pdb + pdb.set_trace() - test_func_mat_exp() \ No newline at end of file + test_func_mat_exp() diff --git a/test/hadamard_grad/test_hadamard_grad.py b/test/hadamard_grad/test_hadamard_grad.py index c6d3d7cd..4857cb15 100644 --- a/test/hadamard_grad/test_hadamard_grad.py +++ b/test/hadamard_grad/test_hadamard_grad.py @@ -2,17 +2,14 @@ from examples.hadamard_grad.circ import Circ1, Circ2, Circ3 from examples.hadamard_grad.hadamard_grad import hadamard_grad + def test_hadamard_grad(): - ''' + """ We assume the circuits have unique and ordered parameters for now. This simplifies the hadamard_grad function so that it only needs to return a list ordered as op_history - ''' + """ - example_circuits = [ - Circ1, - Circ2, - Circ3 - ] + example_circuits = [Circ1, Circ2, Circ3] for Circ in example_circuits: circ = Circ() @@ -21,19 +18,23 @@ def test_hadamard_grad(): # hadamard grad op_history = qdev.op_history n_wires = qdev.n_wires - observable = 'ZZZZ' + observable = "ZZZZ" hadamard_grad_result = hadamard_grad(op_history, n_wires, observable) - hadamard_grad_result = [gradient for gradient in hadamard_grad_result if gradient != None] + hadamard_grad_result = [ + gradient for gradient in hadamard_grad_result if gradient != None + ] # backpropagation expval.backward() # comparison for i, (name, param) in enumerate(circ.named_parameters()): - assert np.isclose(hadamard_grad_result[i], param.grad, atol=0.001), "The gradient for {} is incorrect.".format(name) + assert np.isclose( + hadamard_grad_result[i], param.grad, atol=0.001 + ), "The gradient for {} is incorrect.".format(name) print("tq.hadamard_grad test passed") -if __name__ == "__main__": - test_hadamard_grad() \ No newline at end of file +if __name__ == "__main__": + test_hadamard_grad() diff --git a/test/measurement/test_eval_observable.py b/test/measurement/test_eval_observable.py index 2968fe64..58245ee0 100644 --- a/test/measurement/test_eval_observable.py +++ b/test/measurement/test_eval_observable.py @@ -58,7 +58,9 @@ def test_expval_observable(): random_layer(qdev) expval_tq = expval_joint_analytical(qdev, observable="".join(obs))[0].item() - expval_tq_sampling = expval_joint_sampling(qdev, observable="".join(obs), n_shots=100000)[0].item() + expval_tq_sampling = expval_joint_sampling( + qdev, observable="".join(obs), n_shots=100000 + )[0].item() qiskit_circ = op_history2qiskit(qdev.n_wires, qdev.op_history) operator = pauli_str_op_dict[obs[0]] @@ -75,7 +77,9 @@ def test_expval_observable(): expval_qiskit = (~psi @ operator @ psi).eval().real # print(expval_tq, expval_qiskit) assert np.isclose(expval_tq, expval_qiskit, atol=1e-5) - if n_wires <= 3: # if too many wires, the stochastic method is not accurate due to limited shots + if ( + n_wires <= 3 + ): # if too many wires, the stochastic method is not accurate due to limited shots assert np.isclose(expval_tq_sampling, expval_qiskit, atol=1e-2) print("expval observable test passed") diff --git a/test/measurement/test_expval_joint_sampling_grouping.py b/test/measurement/test_expval_joint_sampling_grouping.py index 3d430c23..09492458 100644 --- a/test/measurement/test_expval_joint_sampling_grouping.py +++ b/test/measurement/test_expval_joint_sampling_grouping.py @@ -23,11 +23,15 @@ """ import torchquantum as tq -from torchquantum.measurement import expval_joint_analytical, expval_joint_sampling_grouping +from torchquantum.measurement import ( + expval_joint_analytical, + expval_joint_sampling_grouping, +) import numpy as np import random + def test_expval_joint_sampling_grouping(): n_obs = 20 n_wires = 4 @@ -44,12 +48,15 @@ def test_expval_joint_sampling_grouping(): expval_ana = {} for obs in obs_all: expval_ana[obs] = expval_joint_analytical(qdev, observable=obs)[0].item() - - expval_sam = expval_joint_sampling_grouping(qdev, observables=obs_all, n_shots_per_group=1000000) + + expval_sam = expval_joint_sampling_grouping( + qdev, observables=obs_all, n_shots_per_group=1000000 + ) for obs in obs_all: - # assert + # assert assert np.isclose(expval_ana[obs], expval_sam[obs][0].item(), atol=1e-2) print(obs, expval_ana[obs], expval_sam[obs][0].item()) -if __name__ == '__main__': + +if __name__ == "__main__": test_expval_joint_sampling_grouping() diff --git a/test/measurement/test_find_observable_groups.py b/test/measurement/test_find_observable_groups.py index c3e81348..656ac4a1 100644 --- a/test/measurement/test_find_observable_groups.py +++ b/test/measurement/test_find_observable_groups.py @@ -25,24 +25,53 @@ from torchquantum.measurement import find_observable_groups from random import shuffle + def test_find_observable_groups(): - in1 = ["XXIII", "YZXXX", "YZIXX", "YZIIX", "YZIIY", - "YZIYI", "YZIYZ", "IZIYI", "ZZZZZ", "ZZZZI", - "IZIIX", "XIZZX"] + in1 = [ + "XXIII", + "YZXXX", + "YZIXX", + "YZIIX", + "YZIIY", + "YZIYI", + "YZIYZ", + "IZIYI", + "ZZZZZ", + "ZZZZI", + "IZIIX", + "XIZZX", + ] out1 = find_observable_groups(in1) - assert out1 == {'YZIYZ': ['YZIYZ'], 'YZIYY': ['YZIIY', 'YZIYI', 'IZIYI'], 'ZZZZZ': ['ZZZZZ', 'ZZZZI'], 'YZXXX': ['YZXXX', 'YZIXX', 'YZIIX', 'IZIIX'], 'XXZZX': ['XXIII', 'XIZZX']} + assert out1 == { + "YZIYZ": ["YZIYZ"], + "YZIYY": ["YZIIY", "YZIYI", "IZIYI"], + "ZZZZZ": ["ZZZZZ", "ZZZZI"], + "YZXXX": ["YZXXX", "YZIXX", "YZIIX", "IZIIX"], + "XXZZX": ["XXIII", "XIZZX"], + } # print(out1) + def find_observable_groups_multi(): - in1 = ["XXIII", "YZXXX", "YZIXX", "YZIIX", "YZIIY", - "YZIYI", "YZIYZ", "IZIYI", "ZZZZZ", "ZZZZI", - "IZIIX", "XIZZX"] + in1 = [ + "XXIII", + "YZXXX", + "YZIXX", + "YZIIX", + "YZIIY", + "YZIYI", + "YZIYZ", + "IZIYI", + "ZZZZZ", + "ZZZZI", + "IZIIX", + "XIZZX", + ] for _ in range(100): shuffle(in1) print(find_observable_groups(in1)) -if __name__ == '__main__': +if __name__ == "__main__": test_find_observable_groups() # find_observable_groups_multi() - diff --git a/test/measurement/test_measure.py b/test/measurement/test_measure.py index 5873d3c7..38c45df6 100644 --- a/test/measurement/test_measure.py +++ b/test/measurement/test_measure.py @@ -30,7 +30,6 @@ def test_measure(): - n_shots = 10000 qdev = tq.QuantumDevice(n_wires=3, bsz=1, record_op=True) qdev.x(wires=2) # type: ignore diff --git a/test/operator/test_ControlledU.py b/test/operator/test_ControlledU.py index 1348862d..5bc01096 100644 --- a/test/operator/test_ControlledU.py +++ b/test/operator/test_ControlledU.py @@ -28,6 +28,7 @@ import torchquantum as tq import torchquantum.functional as tqf from test.utils import check_all_close + # import pdb # pdb.set_trace() import numpy as np @@ -35,6 +36,7 @@ flag = 4 + def test_ContorlledU(): state = tq.QuantumDevice(n_wires=3) # print(state) @@ -43,7 +45,23 @@ def test_ContorlledU(): state.qubitunitaryfast(wires=2, params=[[0, 1], [1, 0]]) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ] + ] + ), + ) state.qubitunitaryfast( wires=[0, 2, 1], params=( @@ -61,12 +79,27 @@ def test_ContorlledU(): ) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) state = tq.QuantumDevice(n_wires=3) # print(state) - gate1 = tq.QubitUnitaryFast(init_params=[[0, 1], [1, 0]], n_wires=1, wires=0) gate1(state) @@ -74,7 +107,23 @@ def test_ContorlledU(): gate2(state) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + ] + ] + ), + ) gate3 = tq.QubitUnitaryFast( init_params=( @@ -97,8 +146,23 @@ def test_ContorlledU(): gate3(state) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) - + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################ state = tq.QuantumDevice(n_wires=2) @@ -110,12 +174,17 @@ def test_ContorlledU(): gate0(state) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array([[0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 0.0j]]), + ) gate(state) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) - + check_all_close( + state.get_states_1d(), + np.array([[0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 1.0 + 0.0j]]), + ) ############################ state = tq.QuantumDevice(n_wires=2) @@ -131,11 +200,12 @@ def test_ContorlledU(): gate0(state) gate(state) - check_all_close(state.get_states_1d(), np.array([[0. +0.j , 0. +0.j , - 0.9921977+0.j , 0. -0.12467473j]])) + check_all_close( + state.get_states_1d(), + np.array([[0.0 + 0.0j, 0.0 + 0.0j, 0.9921977 + 0.0j, 0.0 - 0.12467473j]]), + ) # print(state) - ############################ state = tq.QuantumDevice(n_wires=3) gate0 = tq.PauliX(n_wires=1, wires=0) @@ -152,8 +222,23 @@ def test_ContorlledU(): gate(state) # print(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) - + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################ @@ -171,11 +256,47 @@ def test_ContorlledU(): gate2(state) gate(state) - check_all_close(state.get_states_1d(), - np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################ state = tq.QuantumDevice(n_wires=5) @@ -196,11 +317,47 @@ def test_ContorlledU(): gate3(state) gate(state) - check_all_close(state.get_states_1d(), - np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################ state = tq.QuantumDevice(n_wires=9) @@ -230,71 +387,527 @@ def test_ContorlledU(): gate6(state) gate(state) - check_all_close(state.get_states_1d(), - np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, - 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) ############################## state = tq.QuantumDevice(n_wires=3) @@ -314,8 +927,23 @@ def test_ContorlledU(): gate_ccx(state) - check_all_close(state.get_states_1d(), np.array([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])) - + check_all_close( + state.get_states_1d(), + np.array( + [ + [ + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 0.0 + 0.0j, + 1.0 + 0.0j, + ] + ] + ), + ) if __name__ == "__main__": diff --git a/test/operator/test_op_hamil_exp.py b/test/operator/test_op_hamil_exp.py index de65fa06..082d31b0 100644 --- a/test/operator/test_op_hamil_exp.py +++ b/test/operator/test_op_hamil_exp.py @@ -28,29 +28,56 @@ from test.utils import check_all_close from torchquantum.device import QuantumDevice + def test_op_hamil_exp(): - hamil = Hamiltonian(coeffs=[1.0, 0.5], paulis=['ZZ', 'XX']) - op = OpHamilExp(hamil=hamil, - trainable=True, - theta=0.45) - + hamil = Hamiltonian(coeffs=[1.0, 0.5], paulis=["ZZ", "XX"]) + op = OpHamilExp(hamil=hamil, trainable=True, theta=0.45) + print(op.matrix) print(op.exponent_matrix) check_all_close( op.matrix, - np.array([[ 0.9686-0.2217j, 0.0000+0.0000j, 0.0000+0.0000j, -0.0250-0.1094j], - [ 0.0000+0.0000j, 0.9686+0.2217j, 0.0250-0.1094j, 0.0000+0.0000j], - [ 0.0000+0.0000j, 0.0250-0.1094j, 0.9686+0.2217j, 0.0000+0.0000j], - [-0.0250-0.1094j, 0.0000+0.0000j, 0.0000+0.0000j, 0.9686-0.2217j]]) + np.array( + [ + [ + 0.9686 - 0.2217j, + 0.0000 + 0.0000j, + 0.0000 + 0.0000j, + -0.0250 - 0.1094j, + ], + [ + 0.0000 + 0.0000j, + 0.9686 + 0.2217j, + 0.0250 - 0.1094j, + 0.0000 + 0.0000j, + ], + [ + 0.0000 + 0.0000j, + 0.0250 - 0.1094j, + 0.9686 + 0.2217j, + 0.0000 + 0.0000j, + ], + [ + -0.0250 - 0.1094j, + 0.0000 + 0.0000j, + 0.0000 + 0.0000j, + 0.9686 - 0.2217j, + ], + ] + ), ) check_all_close( op.exponent_matrix, - np.array([[0.-0.2250j, 0.+0.0000j, 0.+0.0000j, 0.-0.1125j], - [0.+0.0000j, 0.+0.2250j, 0.-0.1125j, 0.+0.0000j], - [0.+0.0000j, 0.-0.1125j, 0.+0.2250j, 0.+0.0000j], - [0.-0.1125j, 0.+0.0000j, 0.+0.0000j, 0.-0.2250j]]) + np.array( + [ + [0.0 - 0.2250j, 0.0 + 0.0000j, 0.0 + 0.0000j, 0.0 - 0.1125j], + [0.0 + 0.0000j, 0.0 + 0.2250j, 0.0 - 0.1125j, 0.0 + 0.0000j], + [0.0 + 0.0000j, 0.0 - 0.1125j, 0.0 + 0.2250j, 0.0 + 0.0000j], + [0.0 - 0.1125j, 0.0 + 0.0000j, 0.0 + 0.0000j, 0.0 - 0.2250j], + ] + ), ) qdev = QuantumDevice(n_wires=2) @@ -62,11 +89,26 @@ def test_op_hamil_exp(): check_all_close( qdev.get_states_1d().cpu().detach().numpy(), - np.array([[ 0.9686322 -0.22169423j , 0. +0.j , 0. +0.j, -0.02504631-0.1094314j ], - [ 0.9686322 -0.22169423j , 0. +0.j , 0. +0.j, -0.02504631-0.1094314j ]]) + np.array( + [ + [ + 0.9686322 - 0.22169423j, + 0.0 + 0.0j, + 0.0 + 0.0j, + -0.02504631 - 0.1094314j, + ], + [ + 0.9686322 - 0.22169423j, + 0.0 + 0.0j, + 0.0 + 0.0j, + -0.02504631 - 0.1094314j, + ], + ] + ), ) -if __name__ == '__main__': + +if __name__ == "__main__": # import pdb # pdb.set_trace() test_op_hamil_exp() diff --git a/test/plugin/test_qiskit2tq_op_history.py b/test/plugin/test_qiskit2tq_op_history.py index 48f2c82e..67a67e80 100644 --- a/test/plugin/test_qiskit2tq_op_history.py +++ b/test/plugin/test_qiskit2tq_op_history.py @@ -41,8 +41,8 @@ def test_qiskit2tp_op_history(): print(qmodule.Operator_list) - -if __name__ == '__main__': +if __name__ == "__main__": import pdb + pdb.set_trace() test_qiskit2tp_op_history() diff --git a/test/plugin/test_qiskit_plugins.py b/test/plugin/test_qiskit_plugins.py index 4e4fdb28..3c6665cc 100644 --- a/test/plugin/test_qiskit_plugins.py +++ b/test/plugin/test_qiskit_plugins.py @@ -58,7 +58,9 @@ def test_expval_observable(): random_layer(qdev) qiskit_circ = op_history2qiskit(qdev.n_wires, qdev.op_history) - expval_qiskit_processor = processor.process_circs_get_joint_expval([qiskit_circ], "".join(obs), parallel=False) + expval_qiskit_processor = processor.process_circs_get_joint_expval( + [qiskit_circ], "".join(obs), parallel=False + ) operator = pauli_str_op_dict[obs[0]] for ob in obs[1:]: @@ -73,13 +75,16 @@ def test_expval_observable(): expval_qiskit = (~psi @ operator @ psi).eval().real # print(expval_qiskit_processor, expval_qiskit) - if n_wires <= 3: # if too many wires, the stochastic method is not accurate due to limited shots + if ( + n_wires <= 3 + ): # if too many wires, the stochastic method is not accurate due to limited shots assert np.isclose(expval_qiskit_processor, expval_qiskit, atol=1e-2) print("expval observable test passed") -if __name__ == '__main__': +if __name__ == "__main__": import pdb + pdb.set_trace() test_expval_observable() diff --git a/test/static_mode_test.py b/test/static_mode_test.py index 6c2a3428..a9629a63 100644 --- a/test/static_mode_test.py +++ b/test/static_mode_test.py @@ -29,7 +29,7 @@ import numpy as np from torchpack.utils.logging import logger -from torchquantum.operator.operators import op_name_dict +from torchquantum.operator import op_name_dict from torchquantum.functional import func_name_dict from torchquantum.macro import F_DTYPE from torchquantum.plugin.qiskit import ( diff --git a/test/utils.py b/test/utils.py index a1af86e5..6d3c1686 100644 --- a/test/utils.py +++ b/test/utils.py @@ -26,6 +26,7 @@ import numpy as np import torch + def check_all_close(a, b, rtol=1e-5, atol=1e-4): """Check that all elements of a and b are close.""" if isinstance(a, torch.Tensor): diff --git a/torchquantum/measurement/measurements.py b/torchquantum/measurement/measurements.py index ec0221a0..2220e563 100644 --- a/torchquantum/measurement/measurements.py +++ b/torchquantum/measurement/measurements.py @@ -10,7 +10,8 @@ from collections import Counter, OrderedDict from torchquantum.functional import mat_dict -from torchquantum.operator import op_name_dict, Observable +# from ..operator import op_name_dict, Observable +import torchquantum.operator as op from copy import deepcopy import matplotlib.pyplot as plt @@ -120,10 +121,10 @@ def expval_joint_sampling_grouping( # rotation to the desired basis n_wires = qdev.n_wires - paulix = op_name_dict["paulix"] - pauliy = op_name_dict["pauliy"] - pauliz = op_name_dict["pauliz"] - iden = op_name_dict["i"] + paulix = op.op_name_dict["paulix"] + pauliy = op.op_name_dict["pauliy"] + pauliz = op.op_name_dict["pauliz"] + iden = op.op_name_dict["i"] pauli_dict = {"X": paulix, "Y": pauliy, "Z": pauliz, "I": iden} expval_all_obs = {} @@ -189,10 +190,10 @@ def expval_joint_sampling( """ # rotation to the desired basis n_wires = qdev.n_wires - paulix = op_name_dict["paulix"] - pauliy = op_name_dict["pauliy"] - pauliz = op_name_dict["pauliz"] - iden = op_name_dict["i"] + paulix = op.op_name_dict["paulix"] + pauliy = op.op_name_dict["pauliy"] + pauliz = op.op_name_dict["pauliz"] + iden = op.op_name_dict["i"] pauli_dict = {"X": paulix, "Y": pauliy, "Z": pauliz, "I": iden} qdev_clone = tq.QuantumDevice(n_wires=qdev.n_wires, bsz=qdev.bsz, device=qdev.device) @@ -277,7 +278,7 @@ def expval_joint_analytical( def expval( qdev: tq.QuantumDevice, wires: Union[int, List[int]], - observables: Union[Observable, List[Observable]], + observables: Union[op.Observable, List[op.Observable]], ): all_dims = np.arange(qdev.states.dim()) diff --git a/torchquantum/operator/__init__.py b/torchquantum/operator/__init__.py index 3d08a33e..d3070218 100644 --- a/torchquantum/operator/__init__.py +++ b/torchquantum/operator/__init__.py @@ -22,5 +22,8 @@ SOFTWARE. """ -from .operators import * +from .op_types import * from .op_hamil_exp import * +from .standard_gates import * + +from .standard_gates import op_name_dict diff --git a/torchquantum/operator/op_types.py b/torchquantum/operator/op_types.py index b284cb05..786214a9 100644 --- a/torchquantum/operator/op_types.py +++ b/torchquantum/operator/op_types.py @@ -8,6 +8,18 @@ from typing import Iterable, Union, List from enum import IntEnum +__all__ = [ + "Operator", + "Operation", + "DiagonalOperation", + "Observable", + "WiresEnum", + "NParamsEnum", + "AnyNParams", + "AllWires", + "AnyWires", +] + class WiresEnum(IntEnum): """Integer enumeration class diff --git a/torchquantum/operator/operators.py b/torchquantum/operator/operators.py deleted file mode 100644 index 8e7c9c35..00000000 --- a/torchquantum/operator/operators.py +++ /dev/null @@ -1,238 +0,0 @@ -""" -MIT License - -Copyright (c) 2020-present TorchQuantum Authors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -""" - -import torch -import torch.nn as nn -import torchquantum as tq -import torchquantum.functional.functionals as tqf -import numpy as np - -from enum import IntEnum -from torchquantum.functional import mat_dict -from torchquantum.util.quantization.clifford_quantization import CliffordQuantizer -from abc import ABCMeta -from ..macro import C_DTYPE, F_DTYPE -from torchpack.utils.logging import logger -from typing import Iterable, Union, List - -from .op_types import * -from .hadamard import * -from .paulix import * -from .pauliy import * -from .pauliz import * -from .i import * -from .s import * -from .t import * -from .sx import * -from .swap import * -from .toffoli import * -from .rx import * -from .ry import * -from .rz import * -from .r import * -from .iswap import * -from .ecr import * -from .single_excitation import * -from .global_phase import * -from .phase_shift import * -from .rot import * -from .trainable_unitary import * -from .qft import * -from .xx_min_yy import * -from .xx_plus_yy import * -from .reset import * -from .qubit_unitary import * -from .u1 import * -from .u2 import * -from .u3 import * - -__all__ = [ - "op_name_dict", - "Operator", - "Operation", - "DiagonalOperation", - "Observable", - "Hadamard", - "H", - "SHadamard", - "SH", - "PauliX", - "PauliY", - "PauliZ", - "I", - "S", - "T", - "SX", - "CNOT", - "CZ", - "CY", - "RX", - "RY", - "RZ", - "RXX", - "RYY", - "RZZ", - "RZX", - "SWAP", - "SSWAP", - "CSWAP", - "Toffoli", - "PhaseShift", - "Rot", - "MultiRZ", - "CRX", - "CRY", - "CRZ", - "CRot", - "U", - "U1", - "U2", - "U3", - "CU", - "CU1", - "CU2", - "CU3", - "QubitUnitary", - "QubitUnitaryFast", - "TrainableUnitary", - "TrainableUnitaryStrict", - "MultiCNOT", - "MultiXCNOT", - "Reset", - "SingleExcitation", - "EchoedCrossResonance", - "ECR", - "QFT", - "SDG", - "TDG", - "SXDG", - "CH", - "CCZ", - "ISWAP", - "CS", - "CSDG", - "CSX", - "CHadamard", - "CCZ", - "DCX", - "XXMINYY", - "XXPLUSYY", - "C3X", - "R", - "C4X", - "RC3X", - "RCCX", - "GlobalPhase", - "C3SX", -] - - -op_name_dict = { - "hadamard": Hadamard, - "h": Hadamard, - "shadamard": SHadamard, - "sh": SHadamard, - "paulix": PauliX, - "x": PauliX, - "pauliy": PauliY, - "y": PauliY, - "pauliz": PauliZ, - "z": PauliZ, - "i": I, - "s": S, - "t": T, - "sx": SX, - "cx": CNOT, - "cnot": CNOT, - "cz": CZ, - "cy": CY, - "rx": RX, - "ry": RY, - "rz": RZ, - "rxx": RXX, - "xx": RXX, - "ryy": RYY, - "yy": RYY, - "rzz": RZZ, - "zz": RZZ, - "rzx": RZX, - "zx": RZX, - "swap": SWAP, - "sswap": SSWAP, - "cswap": CSWAP, - "toffoli": Toffoli, - "ccx": Toffoli, - "phaseshift": PhaseShift, - "rot": Rot, - "multirz": MultiRZ, - "crx": CRX, - "cry": CRY, - "crz": CRZ, - "crot": CRot, - "u1": U1, - "p": U1, - "u2": U2, - "u3": U3, - "u": U3, - "cu1": CU1, - "cp": CU1, - "cr": CU1, - "cphase": CU1, - "cu2": CU2, - "cu3": CU3, - "cu": CU, - "qubitunitary": QubitUnitary, - "qubitunitarystrict": QubitUnitaryFast, - "qubitunitaryfast": QubitUnitaryFast, - "trainableunitary": TrainableUnitary, - "trainableunitarystrict": TrainableUnitaryStrict, - "multicnot": MultiCNOT, - "multixcnot": MultiXCNOT, - "reset": Reset, - "singleexcitation": SingleExcitation, - "ecr": ECR, - "echoedcrossresonance": ECR, - "QFT": QFT, - "sdg": SDG, - "cs": CS, - "chadamard": CHadamard, - "ch": CH, - "dcx": DCX, - "xxminyy": XXMINYY, - "xxplusyy": XXPLUSYY, - "c3x": C3X, - "tdg": TDG, - "sxdg": SXDG, - "ch": CH, - "ccz": CCZ, - "iswap": ISWAP, - "csdg": CSDG, - "csx": CSX, - "r": R, - "c3sx": C3SX, - "globalphase": GlobalPhase, - "rccx": RCCX, - "rc3x": RC3X, - "c4x": C4X, -} diff --git a/torchquantum/operator/standard_gates/__init__.py b/torchquantum/operator/standard_gates/__init__.py new file mode 100644 index 00000000..a745c00b --- /dev/null +++ b/torchquantum/operator/standard_gates/__init__.py @@ -0,0 +1,147 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +from .ecr import EchoedCrossResonance, ECR +from .global_phase import GlobalPhase +from .i import I +from .iswap import ISWAP + +# TODO: Make paulix/y/z alias as X/Y/Z +from .paulix import PauliX, CNOT, C4X, C3X, DCX, MultiCNOT, MultiXCNOT +from .pauliy import PauliY, CY +from .pauliz import PauliZ, CZ, CCZ +from .hadamard import Hadamard, SHadamard, CHadamard, H, SH, CH +from .phase_shift import PhaseShift +from .qft import QFT +from .r import R +from .reset import Reset +from .rot import Rot, CRot +from .rx import RX, RXX, CRX +from .ry import RY, RYY, CRY +from .rz import RZ, MultiRZ, RZZ, RZX, CRZ +from .toffoli import Toffoli, CCX, RC3X, RCCX +from .qubit_unitary import QubitUnitary, QubitUnitaryFast +from .trainable_unitary import TrainableUnitary, TrainableUnitaryStrict +from .s import S, SDG, CS, CSDG +from .single_excitation import SingleExcitation +from .swap import SWAP, SSWAP, CSWAP +from .sx import SX, CSX, C3SX, SXDG +from .t import T, TDG +from .u1 import U1, CU1 +from .u2 import U2, CU2 +from .u3 import U3, CU3, CU, U +from .xx_min_yy import XXMINYY +from .xx_plus_yy import XXPLUSYY + +all_variables = [ + EchoedCrossResonance, + ECR, + GlobalPhase, + I, + ISWAP, + PauliX, + CNOT, + C4X, + C3X, + DCX, + MultiCNOT, + MultiXCNOT, + PauliY, + CY, + PauliZ, + CZ, + CCZ, + Hadamard, + SHadamard, + CHadamard, + H, + SH, + CH, + PhaseShift, + QFT, + R, + Reset, + Rot, + CRot, + RX, + RXX, + CRX, + RY, + RYY, + CRY, + RZ, + MultiRZ, + RZZ, + RZX, + CRZ, + Toffoli, + CCX, + RC3X, + RCCX, + S, + SDG, + CS, + CSDG, + SingleExcitation, + SWAP, + SSWAP, + CSWAP, + SX, + CSX, + C3SX, + SXDG, + T, + TDG, + TrainableUnitary, + TrainableUnitaryStrict, + U1, + CU1, + U2, + CU2, + U3, + CU3, + CU, + U, + XXMINYY, + XXPLUSYY, +] + +__all__ = [a().__class__.__name__ for a in all_variables] + +# add the aliased and incomptaible classes +__all__.extend(["U", "CH", "QubitUnitary", "QubitUnitaryFast"]) + +# add the dictionary +__all__.append("op_name_dict") + +# create the operations dictionary +op_name_dict = {x.op_name: x for x in all_variables} + +# add aliases as well +op_name_dict["cx"] = CNOT +op_name_dict["paulix"] = PauliX +op_name_dict["h"] = H +op_name_dict["u"] = U +op_name_dict["qubitunitary"] = QubitUnitary +op_name_dict["qubitunitaryfast"] = QubitUnitaryFast diff --git a/torchquantum/operator/ecr.py b/torchquantum/operator/standard_gates/ecr.py similarity index 76% rename from torchquantum/operator/ecr.py rename to torchquantum/operator/standard_gates/ecr.py index cba13546..32202a34 100644 --- a/torchquantum/operator/ecr.py +++ b/torchquantum/operator/standard_gates/ecr.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class ECR(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "ecr" matrix = mat_dict["ecr"] func = staticmethod(tqf.ecr) @@ -21,3 +22,4 @@ def _matrix(cls, params): EchoedCrossResonance = ECR +EchoedCrossResonance.name = "echoedcrossresonance" diff --git a/torchquantum/operator/global_phase.py b/torchquantum/operator/standard_gates/global_phase.py similarity index 80% rename from torchquantum/operator/global_phase.py rename to torchquantum/operator/standard_gates/global_phase.py index e1b8512d..6dad8825 100644 --- a/torchquantum/operator/global_phase.py +++ b/torchquantum/operator/standard_gates/global_phase.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class GlobalPhase(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 0 + op_name = "globalphase" func = staticmethod(tqf.globalphase) @classmethod diff --git a/torchquantum/operator/hadamard.py b/torchquantum/operator/standard_gates/hadamard.py similarity index 89% rename from torchquantum/operator/hadamard.py rename to torchquantum/operator/standard_gates/hadamard.py index ce447f8d..d2a62657 100644 --- a/torchquantum/operator/hadamard.py +++ b/torchquantum/operator/standard_gates/hadamard.py @@ -1,11 +1,11 @@ -from .op_types import * +from ..op_types import * import torch import torch.nn as nn import torchquantum as tq import torchquantum.functional.functionals as tqf import numpy as np from abc import ABCMeta -from ..macro import C_DTYPE, F_DTYPE +from torchquantum.macro import C_DTYPE, F_DTYPE from torchquantum.functional import mat_dict @@ -14,6 +14,7 @@ class Hadamard(Observable, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "hadamard" eigvals = torch.tensor([1, -1], dtype=C_DTYPE) matrix = mat_dict["hadamard"] func = staticmethod(tqf.hadamard) @@ -35,6 +36,7 @@ class SHadamard(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "shadamard" matrix = mat_dict["shadamard"] func = staticmethod(tqf.shadamard) @@ -48,6 +50,7 @@ class CHadamard(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "chadamard" matrix = mat_dict["chadamard"] func = staticmethod(tqf.chadamard) diff --git a/torchquantum/operator/i.py b/torchquantum/operator/standard_gates/i.py similarity index 86% rename from torchquantum/operator/i.py rename to torchquantum/operator/standard_gates/i.py index 0c73e4dd..36a18c15 100644 --- a/torchquantum/operator/i.py +++ b/torchquantum/operator/standard_gates/i.py @@ -1,6 +1,6 @@ -from .op_types import Observable +from ..op_types import Observable from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class I(Observable, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "i" eigvals = torch.tensor([1, 1], dtype=C_DTYPE) matrix = mat_dict["i"] func = staticmethod(tqf.i) diff --git a/torchquantum/operator/iswap.py b/torchquantum/operator/standard_gates/iswap.py similarity index 81% rename from torchquantum/operator/iswap.py rename to torchquantum/operator/standard_gates/iswap.py index ae8d0504..51bbc04c 100644 --- a/torchquantum/operator/iswap.py +++ b/torchquantum/operator/standard_gates/iswap.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class ISWAP(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "iswap" matrix = mat_dict["iswap"] func = staticmethod(tqf.iswap) diff --git a/torchquantum/operator/paulix.py b/torchquantum/operator/standard_gates/paulix.py similarity index 91% rename from torchquantum/operator/paulix.py rename to torchquantum/operator/standard_gates/paulix.py index c709196b..ced51e33 100644 --- a/torchquantum/operator/paulix.py +++ b/torchquantum/operator/standard_gates/paulix.py @@ -1,6 +1,6 @@ -from .op_types import * +from ..op_types import * from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -13,6 +13,7 @@ class PauliX(Observable, metaclass=ABCMeta): num_params = 0 num_wires = 1 eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + op_name = "paulix" matrix = mat_dict["paulix"] func = staticmethod(tqf.paulix) @@ -33,6 +34,7 @@ class CNOT(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "cnot" matrix = mat_dict["cnot"] func = staticmethod(tqf.cnot) @@ -46,6 +48,7 @@ class C4X(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 5 + op_name = "c4x" matrix = mat_dict["c4x"] func = staticmethod(tqf.c4x) @@ -59,6 +62,7 @@ class C3X(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 4 + op_name = "c3x" matrix = mat_dict["c3x"] func = staticmethod(tqf.c3x) @@ -72,6 +76,7 @@ class DCX(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "dcx" matrix = mat_dict["dcx"] func = staticmethod(tqf.dcx) @@ -85,6 +90,7 @@ class MultiCNOT(Operation, metaclass=ABCMeta): num_params = 0 num_wires = AnyWires + op_name = "multicnot" func = staticmethod(tqf.multicnot) @classmethod @@ -102,6 +108,7 @@ class MultiXCNOT(Operation, metaclass=ABCMeta): num_params = 0 num_wires = AnyWires + op_name = "multixcnot" func = staticmethod(tqf.multixcnot) @classmethod diff --git a/torchquantum/operator/pauliy.py b/torchquantum/operator/standard_gates/pauliy.py similarity index 87% rename from torchquantum/operator/pauliy.py rename to torchquantum/operator/standard_gates/pauliy.py index 3cbee0cc..ed3f0556 100644 --- a/torchquantum/operator/pauliy.py +++ b/torchquantum/operator/standard_gates/pauliy.py @@ -1,6 +1,6 @@ -from .op_types import Observable, Operation +from ..op_types import Observable, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -13,6 +13,7 @@ class PauliY(Observable, metaclass=ABCMeta): num_params = 0 num_wires = 1 eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + op_name = "pauliy" matrix = mat_dict["pauliy"] func = staticmethod(tqf.pauliy) @@ -33,6 +34,7 @@ class CY(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "cy" matrix = mat_dict["cy"] func = staticmethod(tqf.cy) diff --git a/torchquantum/operator/pauliz.py b/torchquantum/operator/standard_gates/pauliz.py similarity index 89% rename from torchquantum/operator/pauliz.py rename to torchquantum/operator/standard_gates/pauliz.py index b8b7f074..a4903147 100644 --- a/torchquantum/operator/pauliz.py +++ b/torchquantum/operator/standard_gates/pauliz.py @@ -1,6 +1,6 @@ -from .op_types import Observable, DiagonalOperation +from ..op_types import Observable, DiagonalOperation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -13,6 +13,7 @@ class PauliZ(Observable, metaclass=ABCMeta): num_params = 0 num_wires = 1 eigvals = torch.tensor([1, -1], dtype=C_DTYPE) + op_name = "pauliz" matrix = mat_dict["pauliz"] func = staticmethod(tqf.pauliz) @@ -34,6 +35,7 @@ class CZ(DiagonalOperation, metaclass=ABCMeta): num_params = 0 num_wires = 2 eigvals = torch.tensor([1, 1, 1, -1], dtype=C_DTYPE) + op_name = "cz" matrix = mat_dict["cz"] func = staticmethod(tqf.cz) @@ -51,6 +53,7 @@ class CCZ(DiagonalOperation, metaclass=ABCMeta): num_params = 0 num_wires = 3 + op_name = "ccz" matrix = mat_dict["ccz"] eigvals = torch.tensor([1, 1, 1, 1, 1, 1, 1, -1], dtype=C_DTYPE) func = staticmethod(tqf.ccz) diff --git a/torchquantum/operator/phase_shift.py b/torchquantum/operator/standard_gates/phase_shift.py similarity index 79% rename from torchquantum/operator/phase_shift.py rename to torchquantum/operator/standard_gates/phase_shift.py index a908490c..d60efd5f 100644 --- a/torchquantum/operator/phase_shift.py +++ b/torchquantum/operator/standard_gates/phase_shift.py @@ -1,6 +1,6 @@ -from .op_types import DiagonalOperation +from ..op_types import DiagonalOperation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class PhaseShift(DiagonalOperation, metaclass=ABCMeta): num_params = 1 num_wires = 1 + op_name = "phaseshift" func = staticmethod(tqf.phaseshift) @classmethod diff --git a/torchquantum/operator/qft.py b/torchquantum/operator/standard_gates/qft.py similarity index 80% rename from torchquantum/operator/qft.py rename to torchquantum/operator/standard_gates/qft.py index 0e1d192d..66ac6022 100644 --- a/torchquantum/operator/qft.py +++ b/torchquantum/operator/standard_gates/qft.py @@ -1,6 +1,6 @@ -from .op_types import Observable, AnyWires +from ..op_types import Observable, AnyWires from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class QFT(Observable, metaclass=ABCMeta): num_params = 0 num_wires = AnyWires + op_name = "qft" func = staticmethod(tqf.qft) @classmethod diff --git a/torchquantum/operator/qubit_unitary.py b/torchquantum/operator/standard_gates/qubit_unitary.py similarity index 96% rename from torchquantum/operator/qubit_unitary.py rename to torchquantum/operator/standard_gates/qubit_unitary.py index 0e8750d4..f6413ed5 100644 --- a/torchquantum/operator/qubit_unitary.py +++ b/torchquantum/operator/standard_gates/qubit_unitary.py @@ -1,10 +1,11 @@ -from .op_types import * +from ..op_types import * from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict import torchquantum.functional.functionals as tqf +import numpy as np class QubitUnitary(Operation, metaclass=ABCMeta): @@ -12,6 +13,7 @@ class QubitUnitary(Operation, metaclass=ABCMeta): num_params = AnyNParams num_wires = AnyWires + op_name = "qubitunitary" func = staticmethod(tqf.qubitunitary) @classmethod @@ -32,6 +34,7 @@ class QubitUnitaryFast(Operation, metaclass=ABCMeta): num_params = AnyNParams num_wires = AnyWires + op_name = "qubitunitaryfast" func = staticmethod(tqf.qubitunitaryfast) def __init__( diff --git a/torchquantum/operator/r.py b/torchquantum/operator/standard_gates/r.py similarity index 79% rename from torchquantum/operator/r.py rename to torchquantum/operator/standard_gates/r.py index 76caf426..34cf50e4 100644 --- a/torchquantum/operator/r.py +++ b/torchquantum/operator/standard_gates/r.py @@ -1,6 +1,6 @@ -from .op_types import DiagonalOperation +from ..op_types import DiagonalOperation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class R(DiagonalOperation, metaclass=ABCMeta): num_params = 2 num_wires = 1 + op_name = "r" func = staticmethod(tqf.r) @classmethod diff --git a/torchquantum/operator/reset.py b/torchquantum/operator/standard_gates/reset.py similarity index 78% rename from torchquantum/operator/reset.py rename to torchquantum/operator/standard_gates/reset.py index 640093cb..d97c4de7 100644 --- a/torchquantum/operator/reset.py +++ b/torchquantum/operator/standard_gates/reset.py @@ -1,6 +1,6 @@ -from .op_types import Operator, AnyWires +from ..op_types import Operator, AnyWires from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class Reset(Operator, metaclass=ABCMeta): num_params = 0 num_wires = AnyWires + op_name = "reset" func = staticmethod(tqf.reset) @classmethod diff --git a/torchquantum/operator/rot.py b/torchquantum/operator/standard_gates/rot.py similarity index 83% rename from torchquantum/operator/rot.py rename to torchquantum/operator/standard_gates/rot.py index fec3d040..ba9fd8bb 100644 --- a/torchquantum/operator/rot.py +++ b/torchquantum/operator/standard_gates/rot.py @@ -1,6 +1,6 @@ -from .op_types import Observable, Operation +from ..op_types import Observable, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class Rot(Operation, metaclass=ABCMeta): num_params = 3 num_wires = 1 + op_name = "rot" func = staticmethod(tqf.rot) @classmethod @@ -24,6 +25,7 @@ class CRot(Operation, metaclass=ABCMeta): num_params = 3 num_wires = 2 + op_name = "crot" func = staticmethod(tqf.crot) @classmethod diff --git a/torchquantum/operator/rx.py b/torchquantum/operator/standard_gates/rx.py similarity index 86% rename from torchquantum/operator/rx.py rename to torchquantum/operator/standard_gates/rx.py index 8773d765..fa805e26 100644 --- a/torchquantum/operator/rx.py +++ b/torchquantum/operator/standard_gates/rx.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class RX(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 1 + op_name = "rx" func = staticmethod(tqf.rx) @classmethod @@ -24,6 +25,7 @@ class RXX(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "rxx" func = staticmethod(tqf.rxx) @classmethod @@ -36,6 +38,7 @@ class CRX(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "crx" func = staticmethod(tqf.crx) @classmethod diff --git a/torchquantum/operator/ry.py b/torchquantum/operator/standard_gates/ry.py similarity index 86% rename from torchquantum/operator/ry.py rename to torchquantum/operator/standard_gates/ry.py index cf4fdedc..f4c7a7a5 100644 --- a/torchquantum/operator/ry.py +++ b/torchquantum/operator/standard_gates/ry.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class RY(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 1 + op_name = "ry" func = staticmethod(tqf.ry) @classmethod @@ -24,6 +25,7 @@ class RYY(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "ryy" func = staticmethod(tqf.ryy) @classmethod @@ -36,6 +38,7 @@ class CRY(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "cry" func = staticmethod(tqf.cry) @classmethod diff --git a/torchquantum/operator/rz.py b/torchquantum/operator/standard_gates/rz.py similarity index 89% rename from torchquantum/operator/rz.py rename to torchquantum/operator/standard_gates/rz.py index 16d07d21..91dee8db 100644 --- a/torchquantum/operator/rz.py +++ b/torchquantum/operator/standard_gates/rz.py @@ -1,6 +1,6 @@ -from .op_types import * +from ..op_types import * from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class RZ(DiagonalOperation, metaclass=ABCMeta): num_params = 1 num_wires = 1 + op_name = "rz" func = staticmethod(tqf.rz) @classmethod @@ -24,6 +25,7 @@ class MultiRZ(DiagonalOperation, metaclass=ABCMeta): num_params = 1 num_wires = AnyWires + op_name = "multirz" func = staticmethod(tqf.multirz) @classmethod @@ -36,6 +38,7 @@ class RZZ(DiagonalOperation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "rzz" func = staticmethod(tqf.rzz) @classmethod @@ -48,6 +51,7 @@ class RZX(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "rzx" func = staticmethod(tqf.rzx) @classmethod @@ -60,6 +64,7 @@ class CRZ(Operation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "crz" func = staticmethod(tqf.crz) @classmethod diff --git a/torchquantum/operator/s.py b/torchquantum/operator/standard_gates/s.py similarity index 90% rename from torchquantum/operator/s.py rename to torchquantum/operator/standard_gates/s.py index 3ab1af93..b91aa0c3 100644 --- a/torchquantum/operator/s.py +++ b/torchquantum/operator/standard_gates/s.py @@ -1,6 +1,6 @@ -from .op_types import DiagonalOperation, Operation +from ..op_types import Operation, DiagonalOperation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -13,6 +13,7 @@ class S(DiagonalOperation, metaclass=ABCMeta): num_params = 0 num_wires = 1 eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) + op_name = "s" matrix = mat_dict["s"] func = staticmethod(tqf.s) @@ -31,6 +32,7 @@ class SDG(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "sdg" matrix = mat_dict["sdg"] func = staticmethod(tqf.sdg) @@ -44,6 +46,7 @@ class CS(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "cs" matrix = mat_dict["cs"] eigvals = torch.tensor([1, 1, 1, 1j], dtype=C_DTYPE) func = staticmethod(tqf.cs) @@ -62,6 +65,7 @@ class CSDG(DiagonalOperation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "csdg" matrix = mat_dict["csdg"] eigvals = torch.tensor([1, 1, 1, -1j], dtype=C_DTYPE) func = staticmethod(tqf.csdg) diff --git a/torchquantum/operator/single_excitation.py b/torchquantum/operator/standard_gates/single_excitation.py similarity index 80% rename from torchquantum/operator/single_excitation.py rename to torchquantum/operator/standard_gates/single_excitation.py index 62e2f18c..2011aca1 100644 --- a/torchquantum/operator/single_excitation.py +++ b/torchquantum/operator/standard_gates/single_excitation.py @@ -1,6 +1,6 @@ -from .op_types import Operator +from ..op_types import Operator from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class SingleExcitation(Operator, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "singleexcitation" func = staticmethod(tqf.singleexcitation) @classmethod diff --git a/torchquantum/operator/swap.py b/torchquantum/operator/standard_gates/swap.py similarity index 87% rename from torchquantum/operator/swap.py rename to torchquantum/operator/standard_gates/swap.py index e3c63e45..1214a4c5 100644 --- a/torchquantum/operator/swap.py +++ b/torchquantum/operator/standard_gates/swap.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class SWAP(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "swap" matrix = mat_dict["swap"] func = staticmethod(tqf.swap) @@ -25,6 +26,7 @@ class SSWAP(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "sswap" matrix = mat_dict["sswap"] func = staticmethod(tqf.sswap) @@ -38,6 +40,7 @@ class CSWAP(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 3 + op_name = "cswap" matrix = mat_dict["cswap"] func = staticmethod(tqf.cswap) diff --git a/torchquantum/operator/sx.py b/torchquantum/operator/standard_gates/sx.py similarity index 89% rename from torchquantum/operator/sx.py rename to torchquantum/operator/standard_gates/sx.py index a367c844..5728839a 100644 --- a/torchquantum/operator/sx.py +++ b/torchquantum/operator/standard_gates/sx.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -13,6 +13,7 @@ class SX(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 1 eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) + op_name = "sx" matrix = mat_dict["sx"] func = staticmethod(tqf.sx) @@ -30,6 +31,7 @@ class CSX(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 2 + op_name = "csx" matrix = mat_dict["csx"] func = staticmethod(tqf.csx) @@ -43,6 +45,7 @@ class C3SX(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 4 + op_name = "c3sx" matrix = mat_dict["c3sx"] func = staticmethod(tqf.c3sx) @@ -56,6 +59,7 @@ class SXDG(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "sxdg" matrix = mat_dict["sxdg"] func = staticmethod(tqf.sxdg) diff --git a/torchquantum/operator/t.py b/torchquantum/operator/standard_gates/t.py similarity index 85% rename from torchquantum/operator/t.py rename to torchquantum/operator/standard_gates/t.py index 920617dc..282fc68b 100644 --- a/torchquantum/operator/t.py +++ b/torchquantum/operator/standard_gates/t.py @@ -1,6 +1,6 @@ -from .op_types import DiagonalOperation, Operation +from ..op_types import DiagonalOperation, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class T(DiagonalOperation, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "t" eigvals = torch.tensor([1, 1j], dtype=C_DTYPE) matrix = mat_dict["t"] func = staticmethod(tqf.t) @@ -30,6 +31,7 @@ class TDG(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 1 + op_name = "tdg" matrix = mat_dict["tdg"] func = staticmethod(tqf.tdg) diff --git a/torchquantum/operator/toffoli.py b/torchquantum/operator/standard_gates/toffoli.py similarity index 85% rename from torchquantum/operator/toffoli.py rename to torchquantum/operator/standard_gates/toffoli.py index 3ca42ed2..d70178b0 100644 --- a/torchquantum/operator/toffoli.py +++ b/torchquantum/operator/standard_gates/toffoli.py @@ -1,6 +1,6 @@ -from .op_types import Operation +from ..op_types import Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class Toffoli(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 3 + op_name = "toffoli" matrix = mat_dict["toffoli"] func = staticmethod(tqf.toffoli) @@ -20,11 +21,15 @@ def _matrix(cls, params): return cls.matrix +CCX = Toffoli + + class RC3X(Operation, metaclass=ABCMeta): """Class for RC3X Gate.""" num_params = 0 num_wires = 4 + op_name = "rc3x" matrix = mat_dict["rc3x"] func = staticmethod(tqf.rc3x) @@ -38,6 +43,7 @@ class RCCX(Operation, metaclass=ABCMeta): num_params = 0 num_wires = 3 + op_name = "rccx" matrix = mat_dict["rccx"] func = staticmethod(tqf.rccx) diff --git a/torchquantum/operator/trainable_unitary.py b/torchquantum/operator/standard_gates/trainable_unitary.py similarity index 92% rename from torchquantum/operator/trainable_unitary.py rename to torchquantum/operator/standard_gates/trainable_unitary.py index 06d56131..c6ea0451 100644 --- a/torchquantum/operator/trainable_unitary.py +++ b/torchquantum/operator/standard_gates/trainable_unitary.py @@ -1,6 +1,6 @@ -from .op_types import * +from ..op_types import * from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class TrainableUnitary(Operation, metaclass=ABCMeta): num_params = AnyNParams num_wires = AnyWires + op_name = "trainableunitary" func = staticmethod(tqf.qubitunitaryfast) def build_params(self, trainable): @@ -55,4 +56,5 @@ class TrainableUnitaryStrict(TrainableUnitary, metaclass=ABCMeta): num_params = AnyNParams num_wires = AnyWires + op_name = "trainableunitarystrict" func = staticmethod(tqf.qubitunitarystrict) diff --git a/torchquantum/operator/u1.py b/torchquantum/operator/standard_gates/u1.py similarity index 84% rename from torchquantum/operator/u1.py rename to torchquantum/operator/standard_gates/u1.py index cecc00c7..e29728f1 100644 --- a/torchquantum/operator/u1.py +++ b/torchquantum/operator/standard_gates/u1.py @@ -1,6 +1,6 @@ -from .op_types import Observable, DiagonalOperation +from ..op_types import Observable, DiagonalOperation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -14,6 +14,7 @@ class U1(DiagonalOperation, metaclass=ABCMeta): num_params = 1 num_wires = 1 + op_name = "u1" func = staticmethod(tqf.u1) @classmethod @@ -26,6 +27,7 @@ class CU1(DiagonalOperation, metaclass=ABCMeta): num_params = 1 num_wires = 2 + op_name = "cu1" func = staticmethod(tqf.cu1) @classmethod diff --git a/torchquantum/operator/u2.py b/torchquantum/operator/standard_gates/u2.py similarity index 83% rename from torchquantum/operator/u2.py rename to torchquantum/operator/standard_gates/u2.py index ea2eb36f..bd22c777 100644 --- a/torchquantum/operator/u2.py +++ b/torchquantum/operator/standard_gates/u2.py @@ -1,6 +1,6 @@ -from .op_types import Observable, Operation +from ..op_types import Observable, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class U2(Operation, metaclass=ABCMeta): num_params = 2 num_wires = 1 + op_name = "u2" func = staticmethod(tqf.u2) @classmethod @@ -24,6 +25,7 @@ class CU2(Operation, metaclass=ABCMeta): num_params = 2 num_wires = 2 + op_name = "cu2" func = staticmethod(tqf.cu2) @classmethod diff --git a/torchquantum/operator/u3.py b/torchquantum/operator/standard_gates/u3.py similarity index 86% rename from torchquantum/operator/u3.py rename to torchquantum/operator/standard_gates/u3.py index 85f0d15e..62279194 100644 --- a/torchquantum/operator/u3.py +++ b/torchquantum/operator/standard_gates/u3.py @@ -1,6 +1,6 @@ -from .op_types import Observable, Operation +from ..op_types import Observable, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class U3(Operation, metaclass=ABCMeta): num_params = 3 num_wires = 1 + op_name = "u3" func = staticmethod(tqf.u3) @classmethod @@ -19,11 +20,15 @@ def _matrix(cls, params): return tqf.u3_matrix(params) +U = U3 + + class CU3(Operation, metaclass=ABCMeta): """Class for Controlled U3 gate.""" num_params = 3 num_wires = 2 + op_name = "cu3" func = staticmethod(tqf.cu3) @classmethod @@ -36,11 +41,9 @@ class CU(Operation, metaclass=ABCMeta): num_params = 4 num_wires = 2 + op_name = "cu" func = staticmethod(tqf.cu) @classmethod def _matrix(cls, params): return tqf.cu_matrix(params) - - -U = U3 diff --git a/torchquantum/operator/xx_min_yy.py b/torchquantum/operator/standard_gates/xx_min_yy.py similarity index 79% rename from torchquantum/operator/xx_min_yy.py rename to torchquantum/operator/standard_gates/xx_min_yy.py index e9913406..5a5e4b00 100644 --- a/torchquantum/operator/xx_min_yy.py +++ b/torchquantum/operator/standard_gates/xx_min_yy.py @@ -1,6 +1,6 @@ -from .op_types import Observable, Operation +from ..op_types import Observable, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class XXMINYY(Operation, metaclass=ABCMeta): num_params = 2 num_wires = 2 + op_name = "xxminyy" func = staticmethod(tqf.xxminyy_matrix) @classmethod diff --git a/torchquantum/operator/xx_plus_yy.py b/torchquantum/operator/standard_gates/xx_plus_yy.py similarity index 79% rename from torchquantum/operator/xx_plus_yy.py rename to torchquantum/operator/standard_gates/xx_plus_yy.py index 61664a09..68de1c7b 100644 --- a/torchquantum/operator/xx_plus_yy.py +++ b/torchquantum/operator/standard_gates/xx_plus_yy.py @@ -1,6 +1,6 @@ -from .op_types import Observable, Operation +from ..op_types import Observable, Operation from abc import ABCMeta -from ..macro import C_DTYPE +from torchquantum.macro import C_DTYPE import torchquantum as tq import torch from torchquantum.functional import mat_dict @@ -12,6 +12,7 @@ class XXPLUSYY(Operation, metaclass=ABCMeta): num_params = 2 num_wires = 2 + op_name = "xxplusyy" func = staticmethod(tqf.xxplusyy_matrix) @classmethod From 15502ea61c039ae302980134d1bd3b1087fc9084 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 15 Sep 2023 08:08:38 -0400 Subject: [PATCH 018/106] [minor] added all aliases --- .../operator/standard_gates/__init__.py | 27 ++++++++++++++----- 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/torchquantum/operator/standard_gates/__init__.py b/torchquantum/operator/standard_gates/__init__.py index a745c00b..b6bcaf12 100644 --- a/torchquantum/operator/standard_gates/__init__.py +++ b/torchquantum/operator/standard_gates/__init__.py @@ -139,9 +139,24 @@ op_name_dict = {x.op_name: x for x in all_variables} # add aliases as well -op_name_dict["cx"] = CNOT -op_name_dict["paulix"] = PauliX -op_name_dict["h"] = H -op_name_dict["u"] = U -op_name_dict["qubitunitary"] = QubitUnitary -op_name_dict["qubitunitaryfast"] = QubitUnitaryFast +op_name_dict.update( + { + "h": H, + "sh": SH, + "u": U, + "qubitunitary": QubitUnitary, + "qubitunitaryfast": QubitUnitaryFast, + "x": PauliX, + "y": PauliY, + "z": PauliZ, + "cx": CNOT, + "xx": RXX, + "yy": RYY, + "zz": RZZ, + "zx": RZX, + "ccx": Toffoli, + "p": U1, + "cp": CU1, + "cr": CU1, + } +) From c893f234b9ee1cce644f60f33b91b422990ff08e Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 15 Sep 2023 08:24:37 -0400 Subject: [PATCH 019/106] moved param_ops and fixed_ops to be automatically generated --- torchquantum/graph/graphs.py | 8 +- torchquantum/layer/layers.py | 2 +- torchquantum/operator/op_types.py | 73 ------------------- .../operator/standard_gates/__init__.py | 5 +- 4 files changed, 9 insertions(+), 79 deletions(-) diff --git a/torchquantum/graph/graphs.py b/torchquantum/graph/graphs.py index 0dd7baa1..45bb13fc 100644 --- a/torchquantum/graph/graphs.py +++ b/torchquantum/graph/graphs.py @@ -238,11 +238,11 @@ def build_static_matrix(self): # for wire_modules in self.wire_module_list: for module in self.flat_module_list: name = module.name - if name in tq.Operator.fixed_ops: + if name in tq.operator.fixed_ops: if name not in self.static_matrix_dict.keys(): # fixed operator, all share one static matrix self.static_matrix_dict[module.name] = module.matrix.to(self.device) - elif name in tq.Operator.parameterized_ops and name not in [ + elif name in tq.operator.parameterized_ops and name not in [ "QubitUnitary", "QubitUnitaryFast", "TrainableUnitary", @@ -281,9 +281,9 @@ def build_static_matrix(self): # for wire_modules in self.wire_module_list: for module in self.flat_module_list: name = module.name - if name in tq.Operator.fixed_ops: + if name in tq.operator.fixed_ops: module.static_matrix = self.static_matrix_dict[name] - elif name in tq.Operator.parameterized_ops and name not in [ + elif name in tq.operator.parameterized_ops and name not in [ "QubitUnitary", "QubitUnitaryFast", "TrainableUnitary", diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index bd88fb13..9f129acc 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -391,7 +391,7 @@ def build_random_layer(self): ) else: operation = op(n_wires=n_op_wires, wires=op_wires) - elif op().name in tq.Operator.parameterized_ops: + elif op().name in tq.operator.parameterized_ops: operation = op(has_params=True, trainable=True, wires=op_wires) else: operation = op(wires=op_wires) diff --git a/torchquantum/operator/op_types.py b/torchquantum/operator/op_types.py index 786214a9..bdf35337 100644 --- a/torchquantum/operator/op_types.py +++ b/torchquantum/operator/op_types.py @@ -53,79 +53,6 @@ class NParamsEnum(IntEnum): class Operator(tq.QuantumModule): """The class for quantum operators.""" - fixed_ops = [ - "Hadamard", - "SHadamard", - "PauliX", - "PauliY", - "PauliZ", - "I", - "S", - "T", - "SX", - "CNOT", - "CZ", - "CY", - "SWAP", - "SSWAP", - "CSWAP", - "Toffoli", - "MultiCNOT", - "MultiXCNOT", - "Reset", - "EchoedCrossResonance", - "QFT", - "SDG", - "TDG", - "SXDG", - "CH", - "CCZ", - "ISWAP", - "CS", - "CSDG", - "CSX", - "CHadamard", - "DCX", - "C3X", - "C3SX", - "RCCX", - "RC3X", - "C4X", - ] - - parameterized_ops = [ - "RX", - "RY", - "RZ", - "RXX", - "RYY", - "RZZ", - "RZX", - "PhaseShift", - "Rot", - "MultiRZ", - "CRX", - "CRY", - "CRZ", - "CRot", - "U1", - "U2", - "U3", - "CU", - "CU1", - "CU2", - "CU3", - "QubitUnitary", - "QubitUnitaryFast", - "TrainableUnitary", - "TrainableUnitaryStrict", - "SingleExcitation", - "XXMINYY", - "XXPLUSYY", - "R", - "GlobalPhase", - ] - @property def name(self): """String for the name of the operator.""" diff --git a/torchquantum/operator/standard_gates/__init__.py b/torchquantum/operator/standard_gates/__init__.py index b6bcaf12..98f55997 100644 --- a/torchquantum/operator/standard_gates/__init__.py +++ b/torchquantum/operator/standard_gates/__init__.py @@ -133,7 +133,7 @@ __all__.extend(["U", "CH", "QubitUnitary", "QubitUnitaryFast"]) # add the dictionary -__all__.append("op_name_dict") +__all__.extend(["op_name_dict", "fixed_ops", "parameterized_ops"]) # create the operations dictionary op_name_dict = {x.op_name: x for x in all_variables} @@ -160,3 +160,6 @@ "cr": CU1, } ) + +fixed_ops = [a().__class__.__name__ for a in all_variables if a.num_params == 0] +parameterized_ops = [a().__class__.__name__ for a in all_variables if a.num_params > 0] From a24f0cf373843096cb584c6125c3aae4f4218bec Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 14 Oct 2023 18:33:36 -0400 Subject: [PATCH 020/106] adding support for generalr/rx/ry --- torchquantum/layer/__init__.py | 1 + torchquantum/layer/general.py | 88 ++++++++++++++++++++++++++++++++++ 2 files changed, 89 insertions(+) create mode 100644 torchquantum/layer/general.py diff --git a/torchquantum/layer/__init__.py b/torchquantum/layer/__init__.py index a6c99385..ce5540cb 100644 --- a/torchquantum/layer/__init__.py +++ b/torchquantum/layer/__init__.py @@ -24,3 +24,4 @@ from .layers import * from .nlocal import * +from .general import * diff --git a/torchquantum/layer/general.py b/torchquantum/layer/general.py new file mode 100644 index 00000000..0a61aa29 --- /dev/null +++ b/torchquantum/layer/general.py @@ -0,0 +1,88 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) + +__all__ = [ + "GlobalR", + "GlobalRX", + "GlobalRY", + "GlobalRZ", +] + + +class GlobalR(tq.QuantumModule): + """Layer Template for a Global R General Gate""" + + def __init__( + self, + n_wires: int = 0, + theta: float = 0, + phi: float = 0, + ): + """Create the layer""" + super().__init__() + self.ops_all = tq.QuantumModuleList() + self.n_wires = n_wires + self.ops_list = [ + {"name": "rot", "params": [phi, theta, 0], "wires": k} + for k in range(self.n_wires) + ] + + @tq.static_support + def forward(self, q_device): + qmodule = tq.QuantumModule.from_op_history(self.ops_list) + qmodule(q_device) + + +class GlobalRX(GlobalR): + """Layer Template for a Global RX General Gate""" + + def __init__( + self, + n_wires: int = 0, + theta: float = 0, + ): + """Create the layer""" + super().__init__(n_wires, theta, phi=0) + + +class GlobalRY(GlobalR): + """Layer Template for a Global RY General Gate""" + + def __init__( + self, + n_wires: int = 0, + theta: float = 0, + ): + """Create the layer""" + super().__init__(n_wires, theta, phi=torch.pi / 2) From 00f6775f1918358ede885f4f0a42ea6f1c1f7f6c Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 14 Oct 2023 19:01:29 -0400 Subject: [PATCH 021/106] broke nlocal into separate files --- torchquantum/layer/nlocal.py | 324 ------------------ torchquantum/layer/nlocal/__init__.py | 6 + torchquantum/layer/nlocal/efficient_su2.py | 64 ++++ .../layer/nlocal/excitation_preserving.py | 65 ++++ torchquantum/layer/nlocal/nlocal.py | 136 ++++++++ torchquantum/layer/nlocal/pauli_two.py | 79 +++++ torchquantum/layer/nlocal/real_amplitudes.py | 64 ++++ torchquantum/layer/nlocal/two_local.py | 91 +++++ 8 files changed, 505 insertions(+), 324 deletions(-) delete mode 100644 torchquantum/layer/nlocal.py create mode 100644 torchquantum/layer/nlocal/__init__.py create mode 100644 torchquantum/layer/nlocal/efficient_su2.py create mode 100644 torchquantum/layer/nlocal/excitation_preserving.py create mode 100644 torchquantum/layer/nlocal/nlocal.py create mode 100644 torchquantum/layer/nlocal/pauli_two.py create mode 100644 torchquantum/layer/nlocal/real_amplitudes.py create mode 100644 torchquantum/layer/nlocal/two_local.py diff --git a/torchquantum/layer/nlocal.py b/torchquantum/layer/nlocal.py deleted file mode 100644 index 1a3c8803..00000000 --- a/torchquantum/layer/nlocal.py +++ /dev/null @@ -1,324 +0,0 @@ -""" -MIT License - -Copyright (c) 2020-present TorchQuantum Authors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -""" - - -import torch -import torchquantum as tq -from torchquantum.layer.layers import ( - LayerTemplate0, - Op1QAllLayer, - Op2QAllLayer, - RandomOp1All, -) - -__all__ = [ - "NLocal", - "TwoLocal", - "ExcitationPreserving", - "EfficientSU2", - "RealAmplitudes", - "PauliTwoDesign", -] - - -class NLocal(LayerTemplate0): - """Layer Template for a NLocal Class - - Args: - rotation_ops (list): gates for the rotation layer as a list of torchquantum operations - entanglement_ops (list): gates for the entanglement layer as a list of torchquantum operations - arch (dict): circuit architecture in a dictionary format - rotation_layer (torchquantum.QuantumModule): type of rotation layer in a torchquantum.QuantumModule format - entanglement_layer (torchquantum.QuantumModule): type of entanglement layer in a torchquantum.QuantumModule format - reps (int): number of reptitions of the rotation and entanglement layers in a integer format - rotation_layer_params (dict): additional parameters for the rotation layer in a dictionary format - entanglement_layer_params (dict): additional parameters for the entanglement layer in a dictionary format - initial_circuit (torchquantum.QuantumModule): initial gates or layer in a QuantumModule format - skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean - """ - - def __init__( - self, - rotation_ops: list = None, - entanglement_ops: list = None, - arch: dict = None, - rotation_layer: tq.QuantumModule = Op1QAllLayer, - entanglement_layer: tq.QuantumModule = Op2QAllLayer, - reps: int = 1, - rotation_layer_params: dict = {}, - entanglement_layer_params: dict = {}, - initial_circuit: tq.QuantumModule = None, - skip_final_rotation_layer: bool = False, - ): - # rotation block options - self.rotation_ops = rotation_ops - self.rotation_layer = rotation_layer - self.rotation_layer_params = rotation_layer_params - - # entanglement block options - self.entanglement_ops = entanglement_ops - self.entanglement_layer = entanglement_layer - self.entanglement_layer_params = entanglement_layer_params - - # extra parameters - self.initial_circuit = initial_circuit - self.skip_final_rotation_layer = skip_final_rotation_layer - self.reps = reps - - # initialize the LayerTemplate0 - super().__init__(arch) - - def build_initial_layer(self): - """Build the initial layer""" - return self.initial_circuit - - def build_rotation_block(self): - """Build rotation block""" - rotation_layers = [] - for rot in self.rotation_ops: - rotation_layers.append( - self.rotation_layer( - op=rot, n_wires=self.n_wires, **self.rotation_layer_params - ) - ) - return rotation_layers - - def build_entanglement_block(self): - """Build entanglement block""" - entanglement_layers = [] - for entanglement in self.entanglement_ops: - entanglement_layers.append( - self.entanglement_layer( - op=entanglement, - n_wires=self.n_wires, - **self.entanglement_layer_params, - ) - ) - return entanglement_layers - - def build_layers(self): - """Build nlocal circuit""" - layers_all = tq.QuantumModuleList() - - # add the initial circuit - initial_circuit = self.build_initial_layer() - if initial_circuit is not None: - layers_all.append(initial_circuit) - - # repeat for each rep - for _ in range(self.reps): - # add rotation blocks to the qubits - layers_all.extend(self.build_rotation_block()) - - # add entanglement blocks to the qubits - layers_all.extend(self.build_entanglement_block()) - - # add final rotation layer - if not self.skip_final_rotation_layer: - layers_all.extend(self.build_rotation_block()) - - # return QuantumModuleList - return layers_all - - -class TwoLocal(NLocal): - """Layer Template for a TwoLocal Class - - Args: - rotation_ops (list): gates for the rotation layer as a list of torchquantum operations - entanglement_ops (list): gates for the entanglement layer as a list of torchquantum operations - arch (dict): circuit architecture in a dictionary format - rotation_layer (torchquantum.QuantumModule): type of rotation layer in a torchquantum.QuantumModule format - entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format - reps (int): number of reptitions of the rotation and entanglement layers in a integer format - entanglement_layer_params (dict): additional parameters for the entanglement layer in a dictionary forma - initial_circuit (torchquantum.QuantumModule): initial gates or layer in a QuantumModule formatt - skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean - """ - - def __init__( - self, - rotation_ops: list = None, - entanglement_ops: list = None, - arch: dict = None, - rotation_layer: tq.QuantumModule = Op1QAllLayer, - entanglement_layer: str = "linear", - reps: int = 1, - entanglement_layer_params: dict = {}, - initial_circuit: tq.QuantumModule = None, - skip_final_rotation_layer: bool = False, - ): - # if passed as string, determine entanglement type - if entanglement_layer == "linear": - entanglement_layer = Op2QAllLayer - elif entanglement_layer == "reverse_linear": - entanglement_layer = Op2QAllLayer - entanglement_layer_params = {"wire_reverse": True} - elif entanglement_layer == "circular": - entanglement_layer = Op2QAllLayer - entanglement_layer_params = {"circular": True} - elif entanglement_layer == "full": - entanglement_layer = Op2QDenseLayer - - # initialize - super().__init__( - arch=arch, - rotation_ops=rotation_ops, - rotation_layer=rotation_layer, - rotation_layer_params={"has_params": True, "trainable": True}, - entanglement_ops=entanglement_ops, - entanglement_layer=entanglement_layer, - entanglement_layer_params=entanglement_layer_params, - initial_circuit=initial_circuit, - reps=reps, - skip_final_rotation_layer=skip_final_rotation_layer, - ) - - -class ExcitationPreserving(TwoLocal): - """Layer Template for a ExcitationPreserving circuit - - Args: - arch (dict): circuit architecture in a dictionary format - entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format - reps (int): number of reptitions of the rotation and entanglement layers in a integer format - skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean - """ - - def __init__( - self, - arch: dict = None, - entanglement_layer: str = "full", - reps: int = 3, - skip_final_rotation_layer: bool = False, - ): - # construct circuit with rotation layers of RZ and entanglement with RXX and RYY - super().__init__( - arch=arch, - rotation_ops=[tq.RZ], - entanglement_ops=[tq.RXX, tq.RYY], - entanglement_layer=entanglement_layer, - entanglement_layer_params={"has_params": True, "trainable": True}, - reps=reps, - skip_final_rotation_layer=skip_final_rotation_layer, - ) - - -class EfficientSU2(TwoLocal): - """Layer Template for a EfficientSU2 circuit - - Args: - arch (dict): circuit architecture in a dictionary format - entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format - reps (int): number of reptitions of the rotation and entanglement layers in a integer format - skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean - """ - - def __init__( - self, - arch: dict = None, - entanglement_layer: str = "reverse_linear", - reps: int = 3, - skip_final_rotation_layer: bool = False, - ): - # construct circuit with rotation layers of RY and RZ and entanglement with CX - super().__init__( - arch=arch, - rotation_ops=[tq.RY, tq.RZ], - entanglement_ops=[tq.CNOT], - entanglement_layer=entanglement_layer, - reps=reps, - skip_final_rotation_layer=skip_final_rotation_layer, - ) - - -class RealAmplitudes(TwoLocal): - """Layer Template for a RealAmplitudes circuit - - Args: - arch (dict): circuit architecture in a dictionary format - entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format - reps (int): number of reptitions of the rotation and entanglement layers in a integer format - skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean - """ - - def __init__( - self, - arch: dict = None, - entanglement_layer: str = "reverse_linear", - reps: int = 3, - skip_final_rotation_layer: bool = False, - ): - # construct circuit with rotation layers of RY and entanglement with CX - super().__init__( - arch=arch, - rotation_ops=[tq.RY], - entanglement_ops=[tq.CNOT], - entanglement_layer=entanglement_layer, - reps=reps, - skip_final_rotation_layer=skip_final_rotation_layer, - ) - - -class PauliTwoDesign(TwoLocal): - """Layer Template for a PauliTwoDesign circuit - - Args: - arch (dict): circuit architecture in a dictionary format - entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format - reps (int): number of reptitions of the rotation and entanglement layers in a integer format - skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean - """ - - def __init__( - self, - arch: dict = None, - entanglement_layer: str = "reverse_linear", - reps: int = 3, - skip_final_rotation_layer: bool = False, - seed: int = 0, - ): - # set seed - self.seed = seed - # construct circuit with entanglement with CX - super().__init__( - arch=arch, - entanglement_ops=[tq.CNOT], - entanglement_layer=entanglement_layer, - reps=reps, - skip_final_rotation_layer=skip_final_rotation_layer, - ) - - def build_initial_layer(self): - # add an initial layer of ry with rotation pi/4 - return tq.QuantumModule.from_op_history( - [ - {"name": "ry", "wires": wire, "params": torch.pi / 4} - for wire in range(self.arch["n_wires"]) - ] - ) - - def build_rotation_block(self): - # make a random layer of rotations - return [RandomOp1All(n_wires=self.n_wires, seed=self.seed)] diff --git a/torchquantum/layer/nlocal/__init__.py b/torchquantum/layer/nlocal/__init__.py new file mode 100644 index 00000000..2b24001e --- /dev/null +++ b/torchquantum/layer/nlocal/__init__.py @@ -0,0 +1,6 @@ +from .nlocal import * +from .two_local import * +from .excitation_preserving import * +from .real_amplitudes import * +from .efficient_su2 import * +from .pauli_two import * diff --git a/torchquantum/layer/nlocal/efficient_su2.py b/torchquantum/layer/nlocal/efficient_su2.py new file mode 100644 index 00000000..c66eea97 --- /dev/null +++ b/torchquantum/layer/nlocal/efficient_su2.py @@ -0,0 +1,64 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) +from .two_local import TwoLocal + +__all__ = [ + "EfficientSU2", +] + +class EfficientSU2(TwoLocal): + """Layer Template for a EfficientSU2 circuit + + Args: + arch (dict): circuit architecture in a dictionary format + entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format + reps (int): number of reptitions of the rotation and entanglement layers in a integer format + skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean + """ + + def __init__( + self, + arch: dict = None, + entanglement_layer: str = "reverse_linear", + reps: int = 3, + skip_final_rotation_layer: bool = False, + ): + # construct circuit with rotation layers of RY and RZ and entanglement with CX + super().__init__( + arch=arch, + rotation_ops=[tq.RY, tq.RZ], + entanglement_ops=[tq.CNOT], + entanglement_layer=entanglement_layer, + reps=reps, + skip_final_rotation_layer=skip_final_rotation_layer, + ) diff --git a/torchquantum/layer/nlocal/excitation_preserving.py b/torchquantum/layer/nlocal/excitation_preserving.py new file mode 100644 index 00000000..5185a315 --- /dev/null +++ b/torchquantum/layer/nlocal/excitation_preserving.py @@ -0,0 +1,65 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) +from .two_local import TwoLocal + +__all__ = [ + "ExcitationPreserving", +] + +class ExcitationPreserving(TwoLocal): + """Layer Template for a ExcitationPreserving circuit + + Args: + arch (dict): circuit architecture in a dictionary format + entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format + reps (int): number of reptitions of the rotation and entanglement layers in a integer format + skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean + """ + + def __init__( + self, + arch: dict = None, + entanglement_layer: str = "full", + reps: int = 3, + skip_final_rotation_layer: bool = False, + ): + # construct circuit with rotation layers of RZ and entanglement with RXX and RYY + super().__init__( + arch=arch, + rotation_ops=[tq.RZ], + entanglement_ops=[tq.RXX, tq.RYY], + entanglement_layer=entanglement_layer, + entanglement_layer_params={"has_params": True, "trainable": True}, + reps=reps, + skip_final_rotation_layer=skip_final_rotation_layer, + ) diff --git a/torchquantum/layer/nlocal/nlocal.py b/torchquantum/layer/nlocal/nlocal.py new file mode 100644 index 00000000..3a58f28b --- /dev/null +++ b/torchquantum/layer/nlocal/nlocal.py @@ -0,0 +1,136 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) + +__all__ = [ + "NLocal", +] + + +class NLocal(LayerTemplate0): + """Layer Template for a NLocal Class + + Args: + rotation_ops (list): gates for the rotation layer as a list of torchquantum operations + entanglement_ops (list): gates for the entanglement layer as a list of torchquantum operations + arch (dict): circuit architecture in a dictionary format + rotation_layer (torchquantum.QuantumModule): type of rotation layer in a torchquantum.QuantumModule format + entanglement_layer (torchquantum.QuantumModule): type of entanglement layer in a torchquantum.QuantumModule format + reps (int): number of reptitions of the rotation and entanglement layers in a integer format + rotation_layer_params (dict): additional parameters for the rotation layer in a dictionary format + entanglement_layer_params (dict): additional parameters for the entanglement layer in a dictionary format + initial_circuit (torchquantum.QuantumModule): initial gates or layer in a QuantumModule format + skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean + """ + + def __init__( + self, + rotation_ops: list = None, + entanglement_ops: list = None, + arch: dict = None, + rotation_layer: tq.QuantumModule = Op1QAllLayer, + entanglement_layer: tq.QuantumModule = Op2QAllLayer, + reps: int = 1, + rotation_layer_params: dict = {}, + entanglement_layer_params: dict = {}, + initial_circuit: tq.QuantumModule = None, + skip_final_rotation_layer: bool = False, + ): + # rotation block options + self.rotation_ops = rotation_ops + self.rotation_layer = rotation_layer + self.rotation_layer_params = rotation_layer_params + + # entanglement block options + self.entanglement_ops = entanglement_ops + self.entanglement_layer = entanglement_layer + self.entanglement_layer_params = entanglement_layer_params + + # extra parameters + self.initial_circuit = initial_circuit + self.skip_final_rotation_layer = skip_final_rotation_layer + self.reps = reps + + # initialize the LayerTemplate0 + super().__init__(arch) + + def build_initial_layer(self): + """Build the initial layer""" + return self.initial_circuit + + def build_rotation_block(self): + """Build rotation block""" + rotation_layers = [] + for rot in self.rotation_ops: + rotation_layers.append( + self.rotation_layer( + op=rot, n_wires=self.n_wires, **self.rotation_layer_params + ) + ) + return rotation_layers + + def build_entanglement_block(self): + """Build entanglement block""" + entanglement_layers = [] + for entanglement in self.entanglement_ops: + entanglement_layers.append( + self.entanglement_layer( + op=entanglement, + n_wires=self.n_wires, + **self.entanglement_layer_params, + ) + ) + return entanglement_layers + + def build_layers(self): + """Build nlocal circuit""" + layers_all = tq.QuantumModuleList() + + # add the initial circuit + initial_circuit = self.build_initial_layer() + if initial_circuit is not None: + layers_all.append(initial_circuit) + + # repeat for each rep + for _ in range(self.reps): + # add rotation blocks to the qubits + layers_all.extend(self.build_rotation_block()) + + # add entanglement blocks to the qubits + layers_all.extend(self.build_entanglement_block()) + + # add final rotation layer + if not self.skip_final_rotation_layer: + layers_all.extend(self.build_rotation_block()) + + # return QuantumModuleList + return layers_all diff --git a/torchquantum/layer/nlocal/pauli_two.py b/torchquantum/layer/nlocal/pauli_two.py new file mode 100644 index 00000000..03a24073 --- /dev/null +++ b/torchquantum/layer/nlocal/pauli_two.py @@ -0,0 +1,79 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) +from .two_local import TwoLocal + +__all__ = [ + "PauliTwoDesign", +] + +class PauliTwoDesign(TwoLocal): + """Layer Template for a PauliTwoDesign circuit + + Args: + arch (dict): circuit architecture in a dictionary format + entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format + reps (int): number of reptitions of the rotation and entanglement layers in a integer format + skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean + """ + + def __init__( + self, + arch: dict = None, + entanglement_layer: str = "reverse_linear", + reps: int = 3, + skip_final_rotation_layer: bool = False, + seed: int = 0, + ): + # set seed + self.seed = seed + # construct circuit with entanglement with CX + super().__init__( + arch=arch, + entanglement_ops=[tq.CNOT], + entanglement_layer=entanglement_layer, + reps=reps, + skip_final_rotation_layer=skip_final_rotation_layer, + ) + + def build_initial_layer(self): + # add an initial layer of ry with rotation pi/4 + return tq.QuantumModule.from_op_history( + [ + {"name": "ry", "wires": wire, "params": torch.pi / 4} + for wire in range(self.arch["n_wires"]) + ] + ) + + def build_rotation_block(self): + # make a random layer of rotations + return [RandomOp1All(n_wires=self.n_wires, seed=self.seed)] diff --git a/torchquantum/layer/nlocal/real_amplitudes.py b/torchquantum/layer/nlocal/real_amplitudes.py new file mode 100644 index 00000000..b676c076 --- /dev/null +++ b/torchquantum/layer/nlocal/real_amplitudes.py @@ -0,0 +1,64 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) +from .two_local import TwoLocal + +__all__ = [ + "RealAmplitudes", +] + +class RealAmplitudes(TwoLocal): + """Layer Template for a RealAmplitudes circuit + + Args: + arch (dict): circuit architecture in a dictionary format + entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format + reps (int): number of reptitions of the rotation and entanglement layers in a integer format + skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean + """ + + def __init__( + self, + arch: dict = None, + entanglement_layer: str = "reverse_linear", + reps: int = 3, + skip_final_rotation_layer: bool = False, + ): + # construct circuit with rotation layers of RY and entanglement with CX + super().__init__( + arch=arch, + rotation_ops=[tq.RY], + entanglement_ops=[tq.CNOT], + entanglement_layer=entanglement_layer, + reps=reps, + skip_final_rotation_layer=skip_final_rotation_layer, + ) diff --git a/torchquantum/layer/nlocal/two_local.py b/torchquantum/layer/nlocal/two_local.py new file mode 100644 index 00000000..ab48d670 --- /dev/null +++ b/torchquantum/layer/nlocal/two_local.py @@ -0,0 +1,91 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + + +import torch +import torchquantum as tq +from torchquantum.layer.layers import ( + LayerTemplate0, + Op1QAllLayer, + Op2QAllLayer, + RandomOp1All, +) +from .nlocal import NLocal + +__all__ = [ + "TwoLocal", +] + +class TwoLocal(NLocal): + """Layer Template for a TwoLocal Class + + Args: + rotation_ops (list): gates for the rotation layer as a list of torchquantum operations + entanglement_ops (list): gates for the entanglement layer as a list of torchquantum operations + arch (dict): circuit architecture in a dictionary format + rotation_layer (torchquantum.QuantumModule): type of rotation layer in a torchquantum.QuantumModule format + entanglement_layer (str): type of entanglement layer in a string ("linear", "reverse_linear", "circular", "full") or tq.QuantumModule format + reps (int): number of reptitions of the rotation and entanglement layers in a integer format + entanglement_layer_params (dict): additional parameters for the entanglement layer in a dictionary forma + initial_circuit (torchquantum.QuantumModule): initial gates or layer in a QuantumModule formatt + skip_final_rotation_layer (bool): whether or not to add the final rotation layer as a boolean + """ + + def __init__( + self, + rotation_ops: list = None, + entanglement_ops: list = None, + arch: dict = None, + rotation_layer: tq.QuantumModule = Op1QAllLayer, + entanglement_layer: str = "linear", + reps: int = 1, + entanglement_layer_params: dict = {}, + initial_circuit: tq.QuantumModule = None, + skip_final_rotation_layer: bool = False, + ): + # if passed as string, determine entanglement type + if entanglement_layer == "linear": + entanglement_layer = Op2QAllLayer + elif entanglement_layer == "reverse_linear": + entanglement_layer = Op2QAllLayer + entanglement_layer_params = {"wire_reverse": True} + elif entanglement_layer == "circular": + entanglement_layer = Op2QAllLayer + entanglement_layer_params = {"circular": True} + elif entanglement_layer == "full": + entanglement_layer = Op2QDenseLayer + + # initialize + super().__init__( + arch=arch, + rotation_ops=rotation_ops, + rotation_layer=rotation_layer, + rotation_layer_params={"has_params": True, "trainable": True}, + entanglement_ops=entanglement_ops, + entanglement_layer=entanglement_layer, + entanglement_layer_params=entanglement_layer_params, + initial_circuit=initial_circuit, + reps=reps, + skip_final_rotation_layer=skip_final_rotation_layer, + ) From c9929e08a4c06e3215393fe55b6b6ecc5ab0411a Mon Sep 17 00:00:00 2001 From: Hanrui Wang Date: Sun, 15 Oct 2023 16:16:03 -0400 Subject: [PATCH 022/106] [minor] add a simplied version of quantumnas --- examples/QuantumNAS/quantumnas.ipynb | 14341 +++++++++++++++++++++++++ 1 file changed, 14341 insertions(+) create mode 100644 examples/QuantumNAS/quantumnas.ipynb diff --git a/examples/QuantumNAS/quantumnas.ipynb b/examples/QuantumNAS/quantumnas.ipynb new file mode 100644 index 00000000..bc8ec0b8 --- /dev/null +++ b/examples/QuantumNAS/quantumnas.ipynb @@ -0,0 +1,14341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "8c9NBZ6t9JlZ", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KaKMLJng1qke", + "outputId": "1bf252ff-2af8-40c6-95d4-e0f5cb7aae80", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installing torchquantum...\n", + "Cloning into 'torchquantum'...\n", + "remote: Enumerating objects: 14088, done.\u001b[K\n", + "remote: Counting objects: 100% (2359/2359), done.\u001b[K\n", + "remote: Compressing objects: 100% (1019/1019), done.\u001b[K\n", + "remote: Total 14088 (delta 1390), reused 2129 (delta 1248), pack-reused 11729\u001b[K\n", + "Receiving objects: 100% (14088/14088), 105.49 MiB | 28.00 MiB/s, done.\n", + "Resolving deltas: 100% (7747/7747), done.\n", + "Updating files: 100% (223/223), done.\n", + "/content/torchquantum\n" + ] + } + ], + "source": [ + "print('Installing torchquantum...')\n", + "!git clone -b isca https://github.com/mit-han-lab/torchquantum.git\n", + "%cd /content/torchquantum\n", + "!pip install --editable . 1>/dev/null\n", + "# print('All required packages have been successfully installed!')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wpUx-xoonx5K", + "outputId": "491e687a-915c-4feb-cacb-c5fe08f5136a", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "arviz 0.15.1 requires matplotlib>=3.2, but you have matplotlib 3.1.3 which is incompatible.\n", + "mizani 0.9.3 requires matplotlib>=3.5.0, but you have matplotlib 3.1.3 which is incompatible.\n", + "plotnine 0.12.3 requires matplotlib>=3.6.0, but you have matplotlib 3.1.3 which is incompatible.\n", + "torchquantum 0.1.7 requires matplotlib>=3.3.2, but you have matplotlib 3.1.3 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mCollecting torchdiffeq\n", + " Downloading torchdiffeq-0.2.3-py3-none-any.whl (31 kB)\n", + "Requirement already satisfied: torch>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from torchdiffeq) (2.0.1+cu118)\n", + "Requirement already satisfied: scipy>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from torchdiffeq) (1.11.3)\n", + "Requirement already satisfied: numpy<1.28.0,>=1.21.6 in /usr/local/lib/python3.10/dist-packages (from scipy>=1.4.0->torchdiffeq) (1.23.5)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (3.12.4)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (4.5.0)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (1.12)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (3.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (3.1.2)\n", + "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (2.0.0)\n", + "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.3.0->torchdiffeq) (3.27.6)\n", + "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.3.0->torchdiffeq) (17.0.2)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.3.0->torchdiffeq) (2.1.3)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.3.0->torchdiffeq) (1.3.0)\n", + "Installing collected packages: torchdiffeq\n", + "Successfully installed torchdiffeq-0.2.3\n" + ] + } + ], + "source": [ + "!pip install tensorflow_model_optimization . 1>/dev/null\n", + "# !ls artifact\n", + "# !cp artifact/aerbackend.py ../../usr/local/lib/python3.7/dist-packages/qiskit/providers/aer/backends/ -r\n", + "# !wget https://www.dropbox.com/s/pvoqeab2z2cazke/max-acc-valid.pt\n", + "!pip install matplotlib==3.1.3 1>/dev/null\n", + "!pip install torchdiffeq\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "w-yEeEJFKfjf", + "outputId": "7d3be931-305d-4e44-b7fa-91bc1adf455a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-10-15 20:02:09-- https://www.dropbox.com/s/pvoqeab2z2cazke/max-acc-valid.pt\n", + "Resolving www.dropbox.com (www.dropbox.com)... 162.125.3.18, 2620:100:6030:18::a27d:5012\n", + "Connecting to www.dropbox.com (www.dropbox.com)|162.125.3.18|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: /s/raw/pvoqeab2z2cazke/max-acc-valid.pt [following]\n", + "--2023-10-15 20:02:09-- https://www.dropbox.com/s/raw/pvoqeab2z2cazke/max-acc-valid.pt\n", + "Reusing existing connection to www.dropbox.com:443.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://uc81abd662c48c14921279d415de.dl.dropboxusercontent.com/cd/0/inline/CFpTc9Q69WYcxJJP7c7HueMNsfG-GvwQoZhE5ZZfVBT-jfD3JDc_biilmNAJOl5RGEC99GUTZdRas4pxTtucpzflTvXh-2va2N9pcijkWMi2u9k1GS0AvyUabZt7x3XPSgjE_OS8BafQFJeBZ5S0hbNU/file# [following]\n", + "--2023-10-15 20:02:09-- https://uc81abd662c48c14921279d415de.dl.dropboxusercontent.com/cd/0/inline/CFpTc9Q69WYcxJJP7c7HueMNsfG-GvwQoZhE5ZZfVBT-jfD3JDc_biilmNAJOl5RGEC99GUTZdRas4pxTtucpzflTvXh-2va2N9pcijkWMi2u9k1GS0AvyUabZt7x3XPSgjE_OS8BafQFJeBZ5S0hbNU/file\n", + "Resolving uc81abd662c48c14921279d415de.dl.dropboxusercontent.com (uc81abd662c48c14921279d415de.dl.dropboxusercontent.com)... 162.125.64.15, 2620:100:6030:15::a27d:500f\n", + "Connecting to uc81abd662c48c14921279d415de.dl.dropboxusercontent.com (uc81abd662c48c14921279d415de.dl.dropboxusercontent.com)|162.125.64.15|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: /cd/0/inline2/CFp3Sb4ZOtKuNnQ-53Bq68RjM98_N_tKFJDIY6QCjAjOvRNdyoFIMW5v4BwV3aVJiwbp-__xXIw7-O2YAebDX917fcU9J02X64BVJpakzU6GaNl6mtQpNjSS9EuIi2lDdUp2ezSNgpuOah537TRmvMwTfVX4ofGN6h7BznB8XrkrdMLFzcmluj3hv06wvNtlhTkcx-amjZzc94Xd5YXvuKEsyK9g8XCVZJdQ9I5sPpos2ocXSdOjs16E8iJXLTeiiCjgZDxgOS2NX1eW6Kz1k2kxyC11Cy6lu0EwUe6jyHCF0Xxv53C1rIawO-tz6Y6NTpN7YnhxYZkMjqj7a6SUiWlLjZGjG3tHsEay2HR3LfdoixeHpetrQ9vo3yukbkWZ1U4/file [following]\n", + "--2023-10-15 20:02:10-- https://uc81abd662c48c14921279d415de.dl.dropboxusercontent.com/cd/0/inline2/CFp3Sb4ZOtKuNnQ-53Bq68RjM98_N_tKFJDIY6QCjAjOvRNdyoFIMW5v4BwV3aVJiwbp-__xXIw7-O2YAebDX917fcU9J02X64BVJpakzU6GaNl6mtQpNjSS9EuIi2lDdUp2ezSNgpuOah537TRmvMwTfVX4ofGN6h7BznB8XrkrdMLFzcmluj3hv06wvNtlhTkcx-amjZzc94Xd5YXvuKEsyK9g8XCVZJdQ9I5sPpos2ocXSdOjs16E8iJXLTeiiCjgZDxgOS2NX1eW6Kz1k2kxyC11Cy6lu0EwUe6jyHCF0Xxv53C1rIawO-tz6Y6NTpN7YnhxYZkMjqj7a6SUiWlLjZGjG3tHsEay2HR3LfdoixeHpetrQ9vo3yukbkWZ1U4/file\n", + "Reusing existing connection to uc81abd662c48c14921279d415de.dl.dropboxusercontent.com:443.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 50439 (49K) [application/octet-stream]\n", + "Saving to: ‘max-acc-valid.pt.1’\n", + "\n", + "max-acc-valid.pt.1 100%[===================>] 49.26K 279KB/s in 0.2s \n", + "\n", + "2023-10-15 20:02:11 (279 KB/s) - ‘max-acc-valid.pt.1’ saved [50439/50439]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://www.dropbox.com/s/pvoqeab2z2cazke/max-acc-valid.pt" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "02aTGqazoQP4", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import argparse\n", + "import os\n", + "import sys\n", + "import pdb\n", + "import numpy as np\n", + "import torch\n", + "import torch.backends.cudnn\n", + "import torch.cuda\n", + "import torch.nn\n", + "import torch.utils.data\n", + "import torchquantum as tq\n", + "import tqdm\n", + "import random\n", + "\n", + "from torchpack.utils import io\n", + "# from torchpack import distributed as dist\n", + "from torchpack.environ import set_run_dir\n", + "from torchpack.utils.config import configs\n", + "from torchpack.utils.logging import logger\n", + "from torchquantum.datasets import MNIST\n", + "import torch.optim as optim\n", + "\n", + "from torchquantum.plugins import tq2qiskit, qiskit2tq\n", + "from torchquantum.utils import (build_module_from_op_list,\n", + " build_module_op_list,\n", + " get_v_c_reg_mapping,\n", + " get_p_c_reg_mapping,\n", + " get_p_v_reg_mapping,\n", + " get_cared_configs)\n", + "from torchquantum.super_utils import get_named_sample_arch\n", + "from torch.utils.tensorboard import SummaryWriter" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p7BluZ5WEw_H", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# **2. QuantumNAS with TorchQuantum**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-cE2SxIwnrM7", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## 2.1 QuantumNAS: Circuit Search and Pruning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LW4qHrUVn5dX", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + " **Goals**\n", + "\n", + "In this sectio you will practice searching an optimal subcircuit from a supercircuit and pruning the searched subcircuit to reduce the impact of noise and improve accuracy on real Quantum Computer. The goals of this assignment are as follows:\n", + "\n", + "- Understand the basic concept of **supercircuit** and **subcircuit**\n", + "- Implement and apply **Evolutionary Search**\n", + "- Implement and apply **Pruning**\n", + "- Get a basic understanding of performance improvement (such as accuracy) from **Evolutionary Search** and **Pruning**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "gWadMc1vsYUs", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import torch\n", + "import torchquantum as tq\n", + "import torchquantum.functional as tqf\n", + "import torch.nn.functional as F\n", + "\n", + "from torchpack.utils.logging import logger\n", + "from torchquantum.encoding import encoder_op_list_name_dict\n", + "from torchquantum.super_layers import super_layer_name_dict\n", + "\n", + "from torchquantum.plugins import (\n", + " tq2qiskit_measurement,\n", + " qiskit_assemble_circs,\n", + " op_history2qiskit,\n", + " op_history2qiskit_expand_params,\n", + ")\n", + "\n", + "class SuperQFCModel0(tq.QuantumModule):\n", + " def __init__(self, arch):\n", + " super().__init__()\n", + " self.arch = arch\n", + " self.n_wires = arch['n_wires']\n", + " # self.q_device = tq.QuantumDevice(n_wires=self.n_wires)\n", + " self.encoder = tq.GeneralEncoder(\n", + " encoder_op_list_name_dict[arch['encoder_op_list_name']]\n", + " )\n", + " self.q_layer = super_layer_name_dict[arch['q_layer_name']](arch)\n", + " self.measure = tq.MeasureAll(tq.PauliZ)\n", + " self.sample_arch = None\n", + "\n", + " def set_sample_arch(self, sample_arch):\n", + " self.sample_arch = sample_arch\n", + " self.q_layer.set_sample_arch(sample_arch)\n", + "\n", + " def count_sample_params(self):\n", + " return self.q_layer.count_sample_params()\n", + "\n", + " def forward(self, x, verbose=False, use_qiskit=False):\n", + " bsz = x.shape[0]\n", + " qdev = tq.QuantumDevice(n_wires=self.n_wires, bsz=bsz, record_op=True, device=x.device)\n", + " # self.q_device.reset_states(bsz=bsz)\n", + "\n", + " if getattr(self.arch, 'down_sample_kernel_size', None) is not None:\n", + " x = F.avg_pool2d(x, self.arch['down_sample_kernel_size'])\n", + "\n", + " x = x.view(bsz, -1)\n", + "\n", + " if use_qiskit:\n", + " # use qiskit to process the circuit\n", + " # create the qiskit circuit for encoder\n", + " self.encoder(qdev, x)\n", + " op_history_parameterized = qdev.op_history\n", + " qdev.reset_op_history()\n", + " encoder_circs = op_history2qiskit_expand_params(self.n_wires, op_history_parameterized, bsz=bsz)\n", + "\n", + " # create the qiskit circuit for trainable quantum layers\n", + " self.q_layer(qdev)\n", + " op_history_fixed = qdev.op_history\n", + " qdev.reset_op_history()\n", + " q_layer_circ = op_history2qiskit(self.n_wires, op_history_fixed)\n", + "\n", + " # create the qiskit circuit for measurement\n", + " measurement_circ = tq2qiskit_measurement(qdev, self.measure)\n", + "\n", + " # assemble the encoder, trainable quantum layers, and measurement circuits\n", + " assembled_circs = qiskit_assemble_circs(\n", + " encoder_circs, q_layer_circ, measurement_circ\n", + " )\n", + "\n", + " # call the qiskit processor to process the circuit\n", + " x0 = self.qiskit_processor.process_ready_circs(qdev, assembled_circs).to( # type: ignore\n", + " x.device\n", + " )\n", + " x = x0\n", + "\n", + " # x = self.qiskit_processor.process_parameterized(\n", + " # self.q_device, self.encoder, self.q_layer, self.measure, x)\n", + " else:\n", + " self.encoder(qdev, x)\n", + " self.q_layer(qdev)\n", + " x = self.measure(qdev)\n", + "\n", + " if verbose:\n", + " logger.info(f\"[use_qiskit]={use_qiskit}, expectation:\\n {x.data}\")\n", + "\n", + " if getattr(self.arch, 'output_len', None) is not None:\n", + " x = x.reshape(bsz, -1, self.arch.output_len).sum(-1)\n", + "\n", + " if x.dim() > 2:\n", + " x = x.squeeze()\n", + "\n", + " x = F.log_softmax(x, dim=1)\n", + " return x\n", + "\n", + " @property\n", + " def arch_space(self):\n", + " space = []\n", + " for layer in self.q_layer.super_layers_all:\n", + " space.append(layer.arch_space)\n", + " # for the number of sampled blocks\n", + " space.append(list(range(self.q_layer.n_front_share_blocks,\n", + " self.q_layer.n_blocks + 1)))\n", + " return space\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q1Xidh0AsopD", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "**Load configs**\n", + "\n", + "The config file describes everything about the model structure." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "724tThVysiJw", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "config_str = '''model:\n", + " arch:\n", + " n_wires: 4\n", + " encoder_op_list_name: 4x4_ryzxy\n", + " n_blocks: 3\n", + " n_layers_per_block: 2\n", + " q_layer_name: u3cu3_s0\n", + " down_sample_kernel_size: 6\n", + " n_front_share_blocks: 1\n", + " n_front_share_wires: 1\n", + " n_front_share_ops: 1\n", + " sampler:\n", + " strategy:\n", + " name: plain\n", + " transpile_before_run: False\n", + " load_op_list: False\n", + "\n", + "dataset:\n", + " name: mnist\n", + " input_name: image\n", + " target_name: digit\n", + "\n", + "optimizer:\n", + " name: adam\n", + " lr: 5e-2\n", + " weight_decay: 1e-4\n", + " lambda_lr: 1e-2\n", + "\n", + "run:\n", + " n_epochs: 40\n", + " bsz: 256\n", + " workers_per_gpu: 2\n", + " device: gpu\n", + "\n", + "debug:\n", + " pdb: False\n", + " set_seed: True\n", + " seed: 42\n", + "\n", + "callbacks:\n", + " - callback: 'InferenceRunner'\n", + " split: 'valid'\n", + " subcallbacks:\n", + " - metrics: 'CategoricalAccuracy'\n", + " name: 'acc/valid'\n", + " - metrics: 'NLLError'\n", + " name: 'loss/valid'\n", + " - callback: 'InferenceRunner'\n", + " split: 'test'\n", + " subcallbacks:\n", + " - metrics: 'CategoricalAccuracy'\n", + " name: 'acc/test'\n", + " - metrics: 'NLLError'\n", + " name: 'loss/test'\n", + " - callback: 'MaxSaver'\n", + " name: 'acc/valid'\n", + " - callback: 'Saver'\n", + " max_to_keep: 10\n", + "\n", + "qiskit:\n", + " use_qiskit: False\n", + " use_real_qc: False\n", + " backend_name: null\n", + " noise_model_name: null\n", + " basis_gates_name: null\n", + " n_shots: 8192\n", + " initial_layout: null\n", + " seed_transpiler: 42\n", + " seed_simulator: 42\n", + " optimization_level: 0\n", + " est_success_rate: False\n", + " max_jobs: 1\n", + "\n", + "\n", + "es:\n", + " random_search: False\n", + " population_size: 100\n", + " parent_size: 20\n", + " mutation_size: 40\n", + " mutation_prob: 0.5\n", + " crossover_size: 40\n", + " n_iterations: 5\n", + " est_success_rate: False\n", + " score_mode: loss_succ\n", + " gene_mask: null\n", + " eval:\n", + " use_noise_model: False\n", + " use_real_qc: False\n", + " bsz: qiskit_max\n", + " n_test_samples: 150\n", + "\n", + "\n", + "prune:\n", + " target_pruning_amount : 0.5\n", + " init_pruning_amount : 0.1\n", + " start_epoch : 0\n", + " end_epoch : 30\n", + "\n", + "'''\n", + "f = open(\"configs.yml\", \"w\")\n", + "f.write(config_str)\n", + "f.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "2N52sKjzssBP", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "configs.load('configs.yml')\n", + "if configs.debug.set_seed:\n", + " torch.manual_seed(configs.debug.seed)\n", + " np.random.seed(configs.debug.seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0kphBPbasxHc", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Load the model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DI6G_q2wsu4T", + "outputId": "f0f3451a-8f41-47ed-ff1f-e4838a059239", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 9912422/9912422 [00:00<00:00, 100055378.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 28881/28881 [00:00<00:00, 33472145.30it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./mnist_data/MNIST/raw/train-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 1648877/1648877 [00:00<00:00, 23373815.90it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./mnist_data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4542/4542 [00:00<00:00, 1021859.61it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./mnist_data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "\u001b[32m[2023-10-15 20:02:51.847]\u001b[0m \u001b[33m\u001b[1mOnly use the front 5000 images as TRAIN set.\u001b[0m\n", + "\u001b[32m[2023-10-15 20:02:51.973]\u001b[0m \u001b[33m\u001b[1mOnly use the front 3000 images as VALID set.\u001b[0m\n", + "\u001b[32m[2023-10-15 20:02:51.991]\u001b[0m \u001b[33m\u001b[1mOnly use the front 300 images as TEST set.\u001b[0m\n", + "\u001b[32m[2023-10-15 20:02:52.549]\u001b[0m \u001b[1mModel Size: 72\u001b[0m\n" + ] + } + ], + "source": [ + "device = torch.device('cuda')\n", + "if isinstance(configs.optimizer.lr, str):\n", + " configs.optimizer.lr = eval(configs.optimizer.lr)\n", + "dataset = MNIST(\n", + " root='./mnist_data',\n", + " train_valid_split_ratio=[0.9, 0.1],\n", + " digits_of_interest=[0, 1, 2, 3],\n", + " n_test_samples=300,\n", + " n_train_samples=5000,\n", + " n_valid_samples=3000,\n", + ")\n", + "dataflow = dict()\n", + "for split in dataset:\n", + " sampler = torch.utils.data.RandomSampler(dataset[split])\n", + " dataflow[split] = torch.utils.data.DataLoader(\n", + " dataset[split],\n", + " batch_size=configs.run.bsz,\n", + " sampler=sampler,\n", + " num_workers=configs.run.workers_per_gpu,\n", + " pin_memory=True)\n", + "model = SuperQFCModel0(configs.model.arch)\n", + "state_dict = io.load('max-acc-valid.pt', map_location='cpu')\n", + "model.load_state_dict(state_dict['model'], strict=False)\n", + "model.to(device)\n", + "model.set_sample_arch([4,4,4,4,4,4,3])\n", + "total_params = sum(p.numel() for p in model.parameters())\n", + "logger.info(f'Model Size: {total_params}')\n", + "\n", + "def log_acc(output_all, target_all, k=1):\n", + " _, indices = output_all.topk(k, dim=1)\n", + " masks = indices.eq(target_all.view(-1, 1).expand_as(indices))\n", + " size = target_all.shape[0]\n", + " corrects = masks.sum().item()\n", + " accuracy = corrects / size\n", + " loss = F.nll_loss(output_all, target_all).item()\n", + " logger.info(f\"Accuracy: {accuracy}\")\n", + " logger.info(f\"Loss: {loss}\")\n", + " return accuracy\n", + "\n", + "def evaluate_gene(gene=None, use_qiskit=False):\n", + " if gene is not None:\n", + " model.set_sample_arch(gene)\n", + " with torch.no_grad():\n", + " target_all = None\n", + " output_all = None\n", + " for feed_dict in tqdm.tqdm(dataflow['test']):\n", + " if configs.run.device == 'gpu':\n", + " # pdb.set_trace()\n", + " inputs = feed_dict[configs.dataset.input_name].cuda(non_blocking=True)\n", + " targets = feed_dict[configs.dataset.target_name].cuda(non_blocking=True)\n", + " else:\n", + " inputs = feed_dict[configs.dataset.input_name]\n", + " targets = feed_dict[configs.dataset.target_name]\n", + " outputs = model(inputs, use_qiskit=use_qiskit)\n", + " if target_all is None:\n", + " target_all = targets\n", + " output_all = outputs\n", + " else:\n", + " target_all = torch.cat([target_all, targets], dim=0)\n", + " output_all = torch.cat([output_all, outputs], dim=0)\n", + " accuracy = log_acc(output_all, target_all)\n", + " return accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CSiUP-4atKk6", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "**Let's use the model to predict MNIST images**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 321 + }, + "id": "phZ_woE_tPOw", + "outputId": "5e5b2ab5-5808-4e31-bf2e-8bc2fe706dd7", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "%matplotlib inline\n", + "n_samples = 10\n", + "for feed_dict in dataflow['test']:\n", + " inputs = feed_dict['image']\n", + " outputs = feed_dict['digit']\n", + " break\n", + "images = inputs[:n_samples]\n", + "# Down sample the image from 28x28 to 4x4.\n", + "# This down sampled image is the circuit input.\n", + "after_down_sample = F.avg_pool2d(images, 6)\n", + "\n", + "# Forward the model to get prediction.\n", + "pred = model(images)\n", + "_, indices = pred.topk(1, dim=1)\n", + "\n", + "# Plot 10 samples with label and prediction.\n", + "fig, axes = plt.subplots(2, n_samples, figsize=(20, 4))\n", + "for k in range(n_samples):\n", + " axes[0, 0].set_ylabel(\"image\")\n", + " if k != 0:\n", + " axes[0, k].yaxis.set_visible(False)\n", + " axes[0, k].set_xlabel(\"Label: {0}\".format(outputs[k]))\n", + " norm = matplotlib.colors.Normalize(vmin=0, vmax=1)\n", + " axes[0, k].imshow(images[k, 0, :, :].cpu(), norm=norm, cmap=\"gray\")\n", + "\n", + " axes[1, 0].set_ylabel(\"downsampled image\")\n", + " if k != 0:\n", + " axes[1, k].yaxis.set_visible(False)\n", + " axes[1, k].set_xlabel(\"Prediction: {0}\".format(indices[k][0]))\n", + " axes[1, k].imshow(after_down_sample[k, 0, :, :], norm=norm, cmap=\"gray\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8gKWWgFDa7ki", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "**Supercircuit and Subcircuit**\n", + "\n", + "We constructed a SuperCircuit by stacking a sufficient number of layers of pre-defined parameterized gates to cover a large *design space*. Then, we have already trained the SuperCircuit by sampling and updating the parameter subsets (SubCircuits) from the SuperCircuit. The performance of a SubCircuit with inherited parameters from the SuperCircuit can provide a reliable relative performance estimation for the individual SubCircuit trained from scratch. In this way, we only pay the training cost once but can evaluate all the SubCircuits fast and efficiently. Hence, the search cost is significantly reduced.\n", + "\n", + "In this supercircuit, there are totally 3 blocks and 2 layers(a U3 layer and a CU3 layer) in each block. The gene (Which covers all *design space*) length is 7. The front 6 positions mean how many front gates we put in the circuit in kth layer. The last position of gene means how many front blocks we put in the circuit.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5abKrxthWvzt", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "![image.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c26bfc83TeDo", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "\n", + "In the following code cell we randomly sample a subcircuit to further show the relation between the subcircuit's architecture and its gene for you to understand.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 374 + }, + "id": "QmunD04ob2ol", + "outputId": "85db142b-4145-47b7-b415-ca02ba59c7a6", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampled gene: [1, 4, 2, 2, 4, 4, 2]\n", + "Circuit depth: 8\n", + "Architecture:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from torchquantum.plugins import tq2qiskit\n", + "gene_choice = model.arch_space\n", + "gene_len = len(gene_choice)\n", + "n_samples=1\n", + "samp_gene = []\n", + "for k in range(gene_len):\n", + " samp_gene.append(random.choices(gene_choice[k])[0])\n", + "print(\"Sampled gene: \" + str(samp_gene))\n", + "model.set_sample_arch(samp_gene)\n", + "circ = tq2qiskit(tq.QuantumDevice(n_wires=model.n_wires), model.q_layer)\n", + "print(\"Circuit depth: {0}\".format(circ.depth()))\n", + "print(\"Architecture:\")\n", + "circ.draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "my1EbXmpk4WH", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "**Different performance between noise-free simulator and noisy simulator**\n", + "On real quantum computers, noise can distort the output of the circuit. In this subsection we will show the accuracy gap brought by noise. We use qiskit's noisy simulator to simulate the noisy environment on real quantum computers.\n", + "\n", + "First, we setup a noisy simulator, **specify the *qubit mapping (layout)*** and attach it to our model." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-MN848gJIxni", + "outputId": "15068df3-3c95-4827-f072-46ec5b52f0b6", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ibmqfactory.load_account:WARNING:2023-10-15 20:05:10,215: Credentials are already in use. The existing account in the session will be replaced.\n" + ] + } + ], + "source": [ + "from torchquantum.plugins import QiskitProcessor\n", + "from qiskit import IBMQ\n", + "IBMQ.save_account('47e33305e658576a384f0450958c9e054d68ea80313c29d44112a47dbc759c67a0b49a3de7e9e9c53cafa149324fd4591470858d68f177b35e6dedddd65c638a', overwrite=True)\n", + "\n", + "processor_real_qc = QiskitProcessor(use_real_qc=False, noise_model_name = 'ibmq_perth', backend_name='ibmq_perth')\n", + "\n", + "processor_real_qc.set_layout([0, 1, 2, 3]) # default layout: virtual qubit 0 for physical qubit 0, ..., virtual qubit 3 for physical qubit 3\n", + "\n", + "model.set_qiskit_processor(processor_real_qc)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8yZ6LMHPyrge", + "outputId": "0194e1f7-56a6-46b3-d587-ff42e95b90a2", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:00<00:00, 7.03it/s]\n", + "\u001b[32m[2023-10-15 20:05:17.760]\u001b[0m \u001b[1mAccuracy: 0.49666666666666665\u001b[0m\n", + "\u001b[32m[2023-10-15 20:05:17.762]\u001b[0m \u001b[1mLoss: 1.208074688911438\u001b[0m\n", + " 0%| | 0/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gene_list = [[3,2,4,4,2,4,1], [3,2,4,4,2,4,2], [3,2,4,4,2,4,3]]\n", + "param_num = []\n", + "accu_noise_free = []\n", + "accu_noisy_model = []\n", + "for gene in gene_list:\n", + " total_params = 3 * sum(gene[k] for k in range(2 * gene[-1]))\n", + " param_num.append(total_params)\n", + " accu_noise_free.append(evaluate_gene(gene=gene, use_qiskit=False))\n", + " accu_noisy_model.append(evaluate_gene(gene=gene, use_qiskit=True))\n", + "\n", + "plt.plot(param_num, accu_noise_free, marker='o', label=\"Noise free accuracy\")\n", + "plt.plot(param_num, accu_noisy_model, marker='o', label=\"Noisy accuracy\")\n", + "plt.ylabel(\"test accuracy\")\n", + "plt.xlabel(\"num of params\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FgBxcCWVWeT1", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Part 1: Search for the best gene\n", + "\n", + "In order to find the best subcircuit in real quantum computer's noisy environment, we need the noisy simulator to search for the best gene." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XN1FxkE2OVhj", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "####Part 1.1: Random Search\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "qsWy34-fOvvJ", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "class RandomSearcher:\n", + " def __init__(self, gene_choice, accuracy_predictor):\n", + " self.gene_choice = gene_choice\n", + " self.gene_len = len(self.gene_choice)\n", + " self.accuracy_predictor = accuracy_predictor\n", + "\n", + " def random_sample(self, sample_num):\n", + " # randomly sample genes\n", + " population = []\n", + " i = 0\n", + " while i < sample_num:\n", + " samp_gene = []\n", + " for k in range(self.gene_len):\n", + " samp_gene.append(random.choices(self.gene_choice[k])[0])\n", + " population.append(samp_gene)\n", + " i += 1\n", + "\n", + " return population\n", + "\n", + " def run_search(self, n_subcircuits=100):\n", + " # sample subcircuits\n", + " self.population = self.random_sample(n_subcircuits)\n", + " # predict the accuracy of subnets\n", + " accs = []\n", + " for gene in self.population:\n", + " accs.append(self.accuracy_predictor(gene=gene, use_qiskit=True))\n", + "\n", + "\n", + " # get the index of the best subnet\n", + " accs = np.array(accs)\n", + " best_idx = accs.argmax()\n", + "\n", + " # return the best subnet\n", + " return accs[best_idx], self.population[best_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "pttB6AAEgjAl", + "outputId": "f396b1ec-d9a3-44b5-88c2-0339b02bcc75", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/2 [00:00\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# get the accuracy and gene of the best subcircuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0macc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_search\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mrun_search\u001b[0;34m(self, n_subcircuits)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0maccs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0maccs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccuracy_predictor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mevaluate_gene\u001b[0;34m(gene, use_qiskit)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_qiskit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 55\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtarget_all\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mtarget_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1499\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1500\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1502\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1503\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, verbose, use_qiskit)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0;31m# call the qiskit processor to process the circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m x0 = self.qiskit_processor.process_ready_circs(qdev, assembled_circs).to( # type: ignore\n\u001b[0m\u001b[1;32m 71\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 72\u001b[0m )\n", + "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs\u001b[0;34m(self, q_device, circs_all, parallel)\u001b[0m\n\u001b[1;32m 720\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 721\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mprocess_ready_circs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq_device\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 722\u001b[0;31m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_ready_circs_get_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparallel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 723\u001b[0m \u001b[0mmeasured_qiskit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_expectations_from_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_wires\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mq_device\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_wires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 724\u001b[0m \u001b[0mmeasured_torch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeasured_qiskit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs_get_counts\u001b[0;34m(self, circs_all, parallel)\u001b[0m\n\u001b[1;32m 695\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 696\u001b[0m \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmultiprocessing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 697\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_job_worker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dicts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 698\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 363\u001b[0m '''\n\u001b[0;32m--> 364\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 366\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 764\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 765\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 766\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 767\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 760\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 761\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 762\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 764\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 605\u001b[0m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 606\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 607\u001b[0;31m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 608\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 319\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 321\u001b[0m \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "agent = RandomSearcher(model.arch_space, evaluate_gene)\n", + "\n", + "# get the accuracy and gene of the best subcircuit\n", + "acc, gene = agent.run_search(10)\n", + "\n", + "print(gene)\n", + "print(acc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tdpXf_JFOpy8", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "####Part 1.2 Evolutionary Search" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RhoZuyUfij_i", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "\n", + "**Evolutionary Search**\n", + "In this part, we will implement a more sample-efficient search algorithm, evolutionary search. Evolutionary search is inspired by the evolution algorithm (or genetic algorithm). A **population** of sub-networks are first sampled from the design space. Then, in each **generation**, we perform random mutation and crossover operations as is shown in the figure above. The sub-networks with highest accuracy will be kept, and this process will be repeated until the number of generations reaches `max_time_budget`. Similar to the random search, throughout the search process, all sub-networks that cannot satisfy the efficiency constraint will be discarded.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Hn6oFg4jiois", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "![evolution.png](data:image/png;base64,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)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "_VMiljqIiu-G", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "class EvolutionarySearcher:\n", + " def __init__(self,\n", + " gene_choice,\n", + " accuracy_predictor,\n", + " configs,\n", + " n_iter):\n", + " self.gene_choice = gene_choice\n", + " self.gene_len = len(self.gene_choice)\n", + " self.accuracy_predictor = accuracy_predictor\n", + " self.n_iterations = n_iter\n", + " self.parent_size = 2 #configs.es.parent_size\n", + " self.mutation_size = 4 #configs.es.mutation_size\n", + " self.mutation_prob = configs.es.mutation_prob\n", + " self.crossover_size = 4 #configs.es.crossover_size\n", + "\n", + " def random_sample(self, sample_num):\n", + " # randomly sample genes\n", + " population = []\n", + " i = 0\n", + " while i < sample_num:\n", + " samp_gene = []\n", + " for k in range(self.gene_len):\n", + " samp_gene.append(random.choices(self.gene_choice[k])[0])\n", + " population.append(samp_gene)\n", + " i += 1\n", + " return population\n", + "\n", + " def ask(self):\n", + " \"\"\"return the solutions\"\"\"\n", + " return self.population\n", + "\n", + " def select_and_transform(self, scores):\n", + " \"\"\"perform evo search according to the scores\"\"\"\n", + "\n", + " # sort the index according to the scores (descending order)\n", + " sorted_idx = (-np.array(scores)).argsort()[:self.parent_size]\n", + "\n", + " # hint: update self.best_solution and self.best_score\n", + " self.best_solution = self.population[sorted_idx[0]]\n", + " self.best_score = scores[sorted_idx[0]]\n", + "\n", + " parents = [self.population[i] for i in sorted_idx]\n", + "\n", + " # mutation\n", + " mutate_population = []\n", + " k = 0\n", + " while k < self.mutation_size:\n", + " mutated_gene = self.mutate(random.choices(parents)[0])\n", + " mutate_population.append(mutated_gene)\n", + " k += 1\n", + "\n", + " # crossover\n", + " crossover_population = []\n", + " k = 0\n", + " while k < self.crossover_size:\n", + " crossovered_gene = self.crossover(random.sample(parents, 2))\n", + " crossover_population.append(crossovered_gene)\n", + " k += 1\n", + "\n", + " self.population = parents + mutate_population + crossover_population\n", + "\n", + " def crossover(self, genes):\n", + " crossovered_gene = []\n", + " for i in range(self.gene_len):\n", + " if np.random.uniform() < 0.5:\n", + " crossovered_gene.append(genes[0][i])\n", + " else:\n", + " crossovered_gene.append(genes[1][i])\n", + " return crossovered_gene\n", + "\n", + " def mutate(self, gene):\n", + " mutated_gene = []\n", + " for i in range(self.gene_len):\n", + " # use np.random.uniform() to decide whether to mutate position i\n", + " # mutate ith position of gene with self.mutation_prob as mutation probability\n", + " if np.random.uniform() < self.mutation_prob:\n", + " mutated_gene.append(random.choices(self.gene_choice[i])[0])\n", + " else:\n", + " mutated_gene.append(gene[i])\n", + " return mutated_gene\n", + "\n", + " def run_search(self):\n", + " # sample subcircuits\n", + " self.population = self.random_sample(self.parent_size + self.mutation_size + self.crossover_size)\n", + " for i in range(self.n_iterations):\n", + " # predict the accuracy of subnets\n", + " accs = []\n", + " for gene in self.population:\n", + " accs.append(self.accuracy_predictor(gene=gene, use_qiskit=True))\n", + " self.select_and_transform(accs)\n", + " logger.info(f\"Best solution: {self.best_solution}\")\n", + " logger.info(f\"Best score: {self.best_score}\")\n", + " # return the best subnet\n", + " return self.best_score, self.best_solution" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "buUm6hVan9lT", + "outputId": "2b3717b3-cc65-4ef9-8236-87dba13e38cd", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/2 [00:00\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# get the accuracy and gene of the best subcircuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0macc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_search\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mrun_search\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[0maccs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 89\u001b[0;31m \u001b[0maccs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccuracy_predictor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 90\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect_and_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maccs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Best solution: {self.best_solution}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mevaluate_gene\u001b[0;34m(gene, use_qiskit)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_qiskit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 55\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtarget_all\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mtarget_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1499\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1500\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1502\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1503\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, verbose, use_qiskit)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0;31m# call the qiskit processor to process the circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m x0 = self.qiskit_processor.process_ready_circs(qdev, assembled_circs).to( # type: ignore\n\u001b[0m\u001b[1;32m 71\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 72\u001b[0m )\n", + "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs\u001b[0;34m(self, q_device, circs_all, parallel)\u001b[0m\n\u001b[1;32m 720\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 721\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mprocess_ready_circs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq_device\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 722\u001b[0;31m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_ready_circs_get_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparallel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 723\u001b[0m \u001b[0mmeasured_qiskit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_expectations_from_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_wires\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mq_device\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_wires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 724\u001b[0m \u001b[0mmeasured_torch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeasured_qiskit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs_get_counts\u001b[0;34m(self, circs_all, parallel)\u001b[0m\n\u001b[1;32m 695\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 696\u001b[0m \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmultiprocessing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 697\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_job_worker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dicts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 698\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 363\u001b[0m '''\n\u001b[0;32m--> 364\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 366\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 764\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 765\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 766\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 767\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 760\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 761\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 762\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 764\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 605\u001b[0m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 606\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 607\u001b[0;31m \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 608\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 319\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 321\u001b[0m \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "agent2 = EvolutionarySearcher(model.arch_space, evaluate_gene, configs, 3)\n", + "\n", + "# get the accuracy and gene of the best subcircuit\n", + "acc, gene = agent2.run_search()\n", + "\n", + "print(gene)\n", + "print(acc)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i2h7bD3qAc4N", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The searched best subcircui's architecture is this:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 614 + }, + "id": "-7uxHQEEAcQu", + "outputId": "dedf78a8-0e21-4268-ffaa-4330b29e4d05", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit depth: 13\n", + "Gate counts: OrderedDict([('cu3', 10), ('u3', 9)])\n", + "Architecture:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.set_sample_arch(gene)\n", + "circ = tq2qiskit(tq.QuantumDevice(n_wires=model.n_wires), model.q_layer)\n", + "print(\"Circuit depth: {0}\".format(circ.depth()))\n", + "print(\"Gate counts: {0}\".format(circ.count_ops()))\n", + "print(\"Architecture:\")\n", + "circ.draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3VdNbEbjMbmA", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "###Part 2: Prune the best subcircuit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "omnamjl3lxGu", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Before pruning, we need to record the parameters for comparision with those after pruning.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "1aNpqCvxWaAM" + }, + "outputs": [], + "source": [ + "import locale\n", + "locale.getpreferredencoding = lambda: \"UTF-8\"" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZRDAMeubWiDh", + "outputId": "475fa8e7-7ede-4b6d-d31f-4d54210fa99c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: tensorflow_model_optimization in /usr/local/lib/python3.10/dist-packages (0.7.5)\n", + "Requirement already satisfied: absl-py~=1.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (1.4.0)\n", + "Requirement already satisfied: dm-tree~=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (0.1.8)\n", + "Requirement already satisfied: numpy~=1.23 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (1.23.5)\n", + "Requirement already satisfied: six~=1.14 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (1.16.0)\n" + ] + } + ], + "source": [ + "!pip install tensorflow_model_optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "tnq4ele1mFcL", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def mod_pi(x):\n", + " while x > np.pi:\n", + " x = x - 2 * np.pi\n", + " while x < -np.pi:\n", + " x = x + 2 * np.pi\n", + " return x\n", + "\n", + "params_before_prune = []\n", + "for param in model.parameters():\n", + " for x in param.reshape(-1):\n", + " params_before_prune.append(mod_pi(x.cpu().detach().numpy()))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1AQjjFuprZqp", + "outputId": "b0b8f573-63b3-4f87-fb1c-4e69ad6c0e0b", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array(1.2060113, dtype=float32), array(2.2385259, dtype=float32), array(-1.831825, dtype=float32), -1.8875616232501429, array(-0.16537467, dtype=float32), array(-1.1199452, dtype=float32), array(-3.0714889, dtype=float32), array(1.319183, dtype=float32), array(1.8012493, dtype=float32), array(-0.55449617, dtype=float32), -1.776839558278219, array(1.1050001, dtype=float32), array(1.3458017, dtype=float32), array(2.2216663, dtype=float32), array(1.2591805, dtype=float32), array(1.3722651, dtype=float32), array(0.46867403, dtype=float32), array(-1.3104833, dtype=float32), array(-2.6374984, dtype=float32), array(1.1927967, dtype=float32), array(-1.537862, dtype=float32), array(-0.961351, dtype=float32), array(-0.6752364, dtype=float32), array(0.6030566, dtype=float32), array(-1.2493807, dtype=float32), array(-1.7007474, dtype=float32), array(0.1528023, dtype=float32), array(-0.5733373, dtype=float32), array(0.05264929, dtype=float32), array(-1.218637, dtype=float32), -0.9736960569964808, 2.276383701954977, array(2.9545443, dtype=float32), array(0.6112427, dtype=float32), array(-1.768812, dtype=float32), -2.8226218859301966, array(0.2936784, dtype=float32), array(2.0202014, dtype=float32), array(0.8791962, dtype=float32), 0.7627599875079554, array(0.3225196, dtype=float32), array(-1.5350167, dtype=float32), array(1.2173138, dtype=float32), array(1.9756929, dtype=float32), array(3.0122225, dtype=float32), array(-0.3282573, dtype=float32), array(0.5098736, dtype=float32), array(-0.5967889, dtype=float32), array(-0.23826292, dtype=float32), array(-0.8825165, dtype=float32), array(-2.1583827, dtype=float32), array(-0.00144892, dtype=float32), array(-1.1891487, dtype=float32), array(2.0944161, dtype=float32), array(1.0276417, dtype=float32), -1.7321627775775355, array(1.5605937, dtype=float32), array(0.4463723, dtype=float32), array(1.2150304, dtype=float32), array(-1.6005719, dtype=float32), array(0.27260005, dtype=float32), array(-0.6578254, dtype=float32), array(0.6727466, dtype=float32), array(-1.172121, dtype=float32), array(1.4109098e-06, dtype=float32), array(0.9533401, dtype=float32), array(0.7146789, dtype=float32), array(-5.851705e-06, dtype=float32), array(-2.014969, dtype=float32), array(0.19204804, dtype=float32), array(-2.6795934e-07, dtype=float32), array(0.74116415, dtype=float32)]\n" + ] + } + ], + "source": [ + "print(params_before_prune)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5M5EUs4Y1k7z", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Build the pruning trainer." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "2M_8ch7LMj8z", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.utils.prune\n", + "from torchquantum.prune_utils import (PhaseL1UnstructuredPruningMethod,\n", + " ThresholdScheduler)\n", + "from torchpack.train import Trainer\n", + "from torchpack.utils.typing import Optimizer, Scheduler\n", + "from torchpack.callbacks.writers import TFEventWriter\n", + "from typing import Any, Callable, Dict\n", + "\n", + "class PruningTrainer(Trainer):\n", + " \"\"\"\n", + " Perform pruning-aware training\n", + " \"\"\"\n", + " def __init__(self, *, model: nn.Module, criterion: Callable,\n", + " optimizer: Optimizer, scheduler: Scheduler) -> None:\n", + " self.model = model\n", + " self.legalized_model = None\n", + " self.criterion = criterion\n", + " self.optimizer = optimizer\n", + " self.scheduler = scheduler\n", + " self.solution = None\n", + " self.score = None\n", + "\n", + " self._parameters_to_prune = None\n", + " self._target_pruning_amount = None\n", + " self._init_pruning_amount = None\n", + " self.prune_amount_scheduler = None\n", + " self.prune_amount = None\n", + "\n", + " self.init_pruning()\n", + "\n", + " @staticmethod\n", + " def extract_prunable_parameters(model: nn.Module) -> list:\n", + " _parameters_to_prune = [\n", + " (module, \"params\")\n", + " for _, module in model.named_modules() if isinstance(module,\n", + " tq.Operator)\n", + " and module.params is not None]\n", + " return _parameters_to_prune\n", + "\n", + " def init_pruning(self) -> None:\n", + " \"\"\"\n", + " Initialize pruning procedure\n", + " \"\"\"\n", + " self._parameters_to_prune = self.extract_prunable_parameters(\n", + " self.model)\n", + " self._target_pruning_amount = configs.prune.target_pruning_amount\n", + " self._init_pruning_amount = configs.prune.init_pruning_amount\n", + " self.prune_amount_scheduler = ThresholdScheduler(\n", + " configs.prune.start_epoch, configs.prune.end_epoch,\n", + " self._init_pruning_amount,\n", + " self._target_pruning_amount)\n", + " self.prune_amount = self._init_pruning_amount\n", + "\n", + " def _remove_pruning(self):\n", + " for module, name in self._parameters_to_prune:\n", + " nn.utils.prune.remove(module, name)\n", + "\n", + " def _prune_model(self, prune_amount) -> None:\n", + " \"\"\"\n", + " Perform global threshold/percentage pruning on the quantum model.\n", + " This function just performs pruning re-parametrization, i.e.,\n", + " record weight_orig and generate weight_mask\n", + " \"\"\"\n", + " # first clear current pruning container, since we do not want cascaded\n", + " # pruning methods\n", + " # remove operation will make pruning permanent\n", + " if self.epoch_num > 1:\n", + " self._remove_pruning()\n", + " # perform global phase pruning based on the given pruning amount\n", + " nn.utils.prune.global_unstructured(\n", + " self._parameters_to_prune,\n", + " pruning_method=PhaseL1UnstructuredPruningMethod,\n", + " amount=prune_amount,\n", + " )\n", + " self.summary.add_scalar('prune_amount', prune_amount)\n", + "\n", + " def _before_epoch(self) -> None:\n", + " self.model.train()\n", + "\n", + " def run_step(self, feed_dict: Dict[str, Any], legalize=False) -> Dict[str, Any]:\n", + " output_dict = self._run_step(feed_dict, legalize=legalize)\n", + " return output_dict\n", + "\n", + " def _run_step(self, feed_dict: Dict[str, Any], legalize=False) -> Dict[str, Any]:\n", + " if configs.run.device == 'gpu':\n", + " inputs = feed_dict[configs.dataset.input_name].cuda(\n", + " non_blocking=True)\n", + " targets = feed_dict[configs.dataset.target_name].cuda(\n", + " non_blocking=True)\n", + " else:\n", + " inputs = feed_dict[configs.dataset.input_name]\n", + " targets = feed_dict[configs.dataset.target_name]\n", + " if legalize:\n", + " outputs = self.legalized_model(inputs)\n", + " else:\n", + " outputs = self.model(inputs)\n", + " loss = self.criterion(outputs, targets)\n", + " nll_loss = loss.item()\n", + " unitary_loss = 0\n", + "\n", + " if loss.requires_grad:\n", + " for k, group in enumerate(self.optimizer.param_groups):\n", + " self.summary.add_scalar(f'lr/lr_group{k}', group['lr'])\n", + "\n", + " self.summary.add_scalar('loss', loss.item())\n", + " self.summary.add_scalar('nll_loss', nll_loss)\n", + " if getattr(self.model, 'sample_arch', None) is not None:\n", + " for writer in self.summary.writers:\n", + " if isinstance(writer, TFEventWriter):\n", + " writer.writer.add_text(\n", + " 'sample_arch', str(self.model.sample_arch),\n", + " self.global_step)\n", + " self.optimizer.zero_grad()\n", + " loss.backward()\n", + " self.optimizer.step()\n", + "\n", + " return {'outputs': outputs, 'targets': targets}\n", + "\n", + " def _after_epoch(self) -> None:\n", + " self.model.eval()\n", + " self.scheduler.step()\n", + " # update pruning amount using the scheduler\n", + " self.prune_amount = self.prune_amount_scheduler.step()\n", + " # prune the model\n", + " self._prune_model(self.prune_amount)\n", + " # commit pruned parameters after training\n", + " if self.epoch_num == self.num_epochs:\n", + " self._remove_pruning()\n", + "\n", + " def _after_step(self, output_dict) -> None:\n", + " pass\n", + "\n", + " def _state_dict(self) -> Dict[str, Any]:\n", + " state_dict = dict()\n", + " # need to store model arch because of randomness of random layers\n", + " state_dict['model_arch'] = self.model\n", + " state_dict['model'] = self.model.state_dict()\n", + " state_dict['optimizer'] = self.optimizer.state_dict()\n", + " state_dict['scheduler'] = self.scheduler.state_dict()\n", + " if getattr(self.model, 'sample_arch', None) is not None:\n", + " state_dict['sample_arch'] = self.model.sample_arch\n", + " try:\n", + " state_dict['q_layer_op_list'] = build_module_op_list(\n", + " self.model.q_layer)\n", + " state_dict['encoder_func_list'] = self.model.encoder.func_list\n", + " except AttributeError:\n", + " logger.warning(f\"No q_layer_op_list or encoder_func_list found, \"\n", + " f\"will not save them\")\n", + "\n", + " if self.solution is not None:\n", + " state_dict['solution'] = self.solution\n", + " state_dict['score'] = self.score\n", + "\n", + " try:\n", + " state_dict['v_c_reg_mapping'] = self.model.measure.v_c_reg_mapping\n", + " except AttributeError:\n", + " logger.warning(f\"No v_c_reg_mapping found, will not save it.\")\n", + " return state_dict\n", + "\n", + " def _load_state_dict(self, state_dict: Dict[str, Any]) -> None:\n", + " # self.model.load_state_dict(state_dict['model'])\n", + " self.optimizer.load_state_dict(state_dict['optimizer'])\n", + " self.scheduler.load_state_dict(state_dict['scheduler'])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VuuhStq21gJ8", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Some callbacks function useful for pruning." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "id": "MDCcYTS8P1ht", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from torchpack.callbacks import (InferenceRunner, MaxSaver, Saver, CategoricalAccuracy)\n", + "from examples.gradient_pruning.callbacks import NLLError\n", + "\n", + "def get_subcallbacks(config):\n", + " subcallbacks = []\n", + " for subcallback in config:\n", + " if subcallback['metrics'] == 'CategoricalAccuracy':\n", + " subcallbacks.append(\n", + " CategoricalAccuracy(name=subcallback['name'])\n", + " )\n", + " elif subcallback['metrics'] == 'NLLError':\n", + " subcallbacks.append(\n", + " NLLError(name=subcallback['name'])\n", + " )\n", + " else:\n", + " raise NotImplementedError(subcallback['metrics'])\n", + " return subcallbacks\n", + "\n", + "\n", + "def make_callbacks(dataflow):\n", + " callbacks = []\n", + " for config in configs['callbacks']:\n", + " if config['callback'] == 'InferenceRunner':\n", + " callback = InferenceRunner(\n", + " dataflow=dataflow[config['split']],\n", + " callbacks=get_subcallbacks(config['subcallbacks'])\n", + " )\n", + " elif config['callback'] == 'Saver':\n", + " callback = Saver(max_to_keep=config['max_to_keep'])\n", + " elif config['callback'] == 'MaxSaver':\n", + " callback = MaxSaver(config['name'])\n", + " else:\n", + " raise NotImplementedError(config['callback'])\n", + " callbacks.append(callback)\n", + "\n", + " return callbacks\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WywirsgA1tXq", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "You can set the pruning ratio on your own. If you have tried a pruning ratio and want to try another, simply change the pruning ratio and rerun the following codecell." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "b7270619be5b4e638c49ab9543ec5610", + "65fc01a8608846d185bac6a498c4694c", + "902476f4033b4c2e9ca49aaef966e117", + "44954230ed0a4fe9a416604c59f6e58e", + "d60ba45ddde4424c96331d083a91a187", + "103457d1e98b434dbbdbfac203bf9b90", + "1d975fd51c7c49b0aa19b1635b98bc2f", + "beec379e14b44b0aaf26bf4fd763c835", + "069ba0d8ae3346aab9b139d55a1d1705", + "9a29fe7dd04f4b9f95070a39f0cf2e23", + "df57df5495924f95a2c2e3f8855dd121", + "9738d0ac2d50413b8b45fd30d3896e02", + "972e0f1d733b4993a4cae82fc47e124d", + "8bdd09525f45448fa9eec393b9e06082", + "d7bdad9f9355485695fdbc6f2731fad4", + "33991b02f66d42efb8ee9d048df52c8d", + "6de2285eac56405bb60a3e3c7f4c21d9", + "68ed37e451e0498f9ed9fd2ea2a5531b", + "5d9b0a399157483bb79c0936347df4dd", + "f1e2794dd40541399316d77d2ae30c40", + "4d87f28dce814e9d8a4abf84e30d02b5", + "01c6b75083b949afab571f99ea5f2275", + "2e5859150aa24fe4992346e26b0923a7", + "ddc20c1e23e348f69980e0c37736409e", + "f5e24770e5e341e39b341869796db2a7", + "153c07684894462088d68a6883d51e3b", + "572ae926714d4804bb99aa41684720c5", + "8913810f447b471e9eb96e11a64c18eb", + "12d65b7f3cda42b784484a31f672e379", + "c4c7988172154020abf7ca546250bd45", + "ae64800630624d06b600aa63200a7753", + "d739f5cb184f49b8b61ab4b4edc6646d", + "ce13cadf5f94487696c870f956f41147", + "ceb7e9da20e0440382d80bbe23580848", + "f4c1939a308544b8aad47c011eaeb07b", + "6d856a27234c4437b3ec49ca4eeca36d", + "a1258da98bbc487d8a2410695c982508", + "1199ffb349584d7599d7240e26653580", + "48157fc41bd64f8cbd1dc3e9863eca97", + "01a717c12a494f9bade13620b195cfd9", + "0c8d3178f8294b50896c13599aef3b2a", + "fae629f7891846c6bd4eb39795053d6b", + "dc842e0a59df48169437db4b2106e524", + "6fb2cdd8154940eabdcc7a470f26d37e", + "1467002494a44ff782881592c8ec91b2", + "8b937d390a2e431c87aa7d01de20423a", + "7d8c09a01dbd44dc8056409402e4e9c7", + "150543e4fb284b1481041eac10ada746", + "5002ef29438248cfb56146eafdb02ff1", + "9f384cc0c9bd4f1c96b58b22b094446e", + "503680c2cf6e43589d795cdb3a8cb949", + "b9653be5f6554faab6521f15d632fe60", + "41b6b4ecd14340beba715f7eff584c90", + "341ee0c0cc184a6ebbeae4209a36258f", + "bb68b50116cd4f1f9c15fce1770d3105", + "2ef02ac3d9fe40e58bd4ac387742ce35", + "50e44bcb6282447ba718d54b3eb63318", + "bec72bacba0b4d5e9d650dfe7ca6e77e", + "7b0ee4d02db34b2a8b1896639f54a862", + "1330aecb41c640deb7a8a49df564f1a7", + "4374447a37e449b09111aecb5e216f99", + "801c8d0b42e14241b6be8a30e2cd9aac", + "1b13c08c7e55498686b31e6519ab618a", + "689257a51152408db4d93f98d0e62a78", + "ba2c117a55784623af4b49a92efa9451", + "d855437dc30d4c1db0ab25854763140c", + "2ade945fa7d74bb29579e243813214fe", + "aeb6c118f3704e35b54f95fecf97657a", + "2f84b7d105e94f7b88cf8c53d07087fa", + "1057e14d89fa4f85a2dfb4693bb5557f", + "507e2b30906e47418f2167cb5d2066db", + "8cb378b74173480da6069536f3cc752b", + "f015c88c2412411f854871c14388cc5d", + "88ef4ca635394253b00dc164e7f9f51e", + "64748cb1cf2e4d0cbc0ff7b9813fe35b", + "bb53df44d0c740bfac7920a5164c6e70", + "7caef7151a9249d8a11960bee05df66b", + "882aaa8ea30149248018563b95d64cef", + "6cf3bea675b040aabf28a88694280385", + "79f61439f4db45e38c5d3ea1709fa786", + "fd025febe00e4b06a7c9e6204fc08b50", + "d9b9fd061ebc4f6f9d9587d17062f3f6", + "0b4d00274f3345cc916460ab7de92d88", + "e5558cda2ad74becb5a20cff6b1195b8", + "e5b60e57eac84a8daec873bdf663ff78", + "e40f2266ce194eabbf6bde90c195cc3f", + "a8b986636cbc4ddc8fabd880897db568", + "34ab1d45802044c1a1a8d85691015681", + "de534eba45b74551a7d8ba5e90971f12", + "38b5d9bce9924321bb7952c4ee22dfdb", + "ec0105fb3abe4f4db387b4a98d38cc71", + "3996067baf8647a3951e00a7e8fc9148", + "b4eb50d852fd46c9b675caab8070ec36", + "09fcdf4a98474d218ce6c783fb8bf858", + "9e4f6ee70e1942f6aea5ee9e34c4cc36", + "8328a3bfda174305956041df2dccb259", + "6d4e5f40efd64ac5b6d69754472ccf36", + "97bbead0378d41e2bdcd20c786a69ba5", + "0beb88257c7844fa9b8a634d7ebeedc1", + "27efd00b555c4634ab5b45bdbf983109", + "ce22ae9633ce44f0bed4017bbf9be9da", + "46320ad8dfff492d8cad5e1313981592", + "43356d3e10f34b48ac4e29428a6916d6", + "52e606a5d3a44292818324e2be53c136", + "91381de219ac47739b8e0907e487583e", + "0a45c5c6690947f9abfb5e8c13c78826", + "aba185ddea19446a816c4a865cd26b31", + "9530de20144c4cb3901561e0d725fad2", + "8f5d6456620a4c1089cc854e154cc9b4", + "64e22301d6e44864b4f751ad6c115858", + "9ffacb579af6479392fb6d9aa83922bf", + "4c0a81679d06428a8edb3d5bb00f5849", + "07b5b61ee48246cca5b1de06d4bcf097", + "c43d55b254b443cebd61b8ad84bca9ac", + "627f1f3b5a1e40d5a83b1046e22c0167", + "269397ad6d234b779acf2580f3d68082", + "549a22d7772149b7a924b2e924ab9ec1", + "53b7565f0f1f43108a4d945fc60806e3", + "f12f039497c646bdabf7f735e7973665", + "2a32af82ab86434fa38c169ea82d762f", + "e30a841229f3449cb0bab37a0ac662ee", + "1c9694d5efcb47d0a615c0a11f97209c", + "06785380fb8b43f7a83d7c18b8336dfc", + "e4d556d781194a018bcdb0768abf2584", + "6b308556ac31444f86374ea813396b75", + "b3bfc0a50026417498d814455b3e6528", + "e0ce8f98ad1c4e639a86daf88cd844a3", + "0e165d79e425494ca0d7c37a0e7a372b", + "286cca83cfa14b57ad63fd90baafe6fe", + "0e72173e1bdc4787ad92102d0a60015e", + "0fefed8032784463ba00125da7211e45", + "17fb1d205d124628b13ec46fcda73014", + "33aa492ce3854ef19c3c1279a2b58a5a", + "e5535812c2794fd99bfe3c80c8d924e4", + "dc511da3d8034266b6bb8070e0fc4796", + "5e0dee9c9cd74a0fb69b16a8f890bbca", + "9b68eb45f4824fe09a35fdfed01e6b84", + "010a745b57464f218702d4e8e4f6a9c1", + "41d8c0c48e9e45468fb80763df83eaf2", + "78f3c6c9183649c1804a9169bcbd4fe2", + "d39f14ae61084b55abb92b9d6ac7706e", + "b30f7e59474d4436acad24f4c96a1e1b", + "3057a16ecbc6426d9075a63c65eb3788", + "d3320caa762546d5b68f862bfda1a610", + "9d87317235394b3fa4b7b44b94713d99", + "243a82ddfc734be397b896db73d600e8", + "643044d3241e42acac6caa904c427672", + "a73a24f103a4473d8f91f7ee25b96e7c", + "6538daa9bb3b498d96332c98b1f7d723", + "2f6711f9abe94245a58399b38077abfa", + "ebeac59943ed4e5d9448b3e395037cbe", + "f9d771a613144a18ab0271812bd3842b", + "3c084f1f743f489bb3c7cf30b2dce6f3", + "3e20d81230fe4a4ca07892d58a18f8fd", + "992c199e1c85444c9727a0bd2ae5dbd2", + "354053feba474fefb583661c26bf7546", + "aaa208280ffa4e9ba9aa2dfa9a3e5236", + "35aefb99cd054ca184d12bec5a4de805", + "6e5bc2858bc342fb95383ec05ec1ed50", + "32cdbee5dd984e2ab72df6e9aec7f9e8", + "19e04a3cf7204f38bdd130c8204799cf", + "f93e99b23ab24f359c2dea674611dbb4", + "3bb9c81dc321483abc2b493c57b10e79", + "96147fdf695b4ee489c1b3f6339b746e", + "55f9bd1947b043e0b979594892c09e97", + "4abd54da2cb64417843d23e6f83f97d9", + "ef1fdca48c0448748eca0e1fba68779b", + "bffb3950a3614e22b2f8d5213a70d89d", + "4c09b008802e4bbfad8b698355056f14", + "402d70f3ae3c484b80e9885ae2ed1bae", + "6a39c54e39b048cb86056b70fc0fd224", + "7ed7914804514338b5142eaca84e8e4c", + "a3f22c44214940ff9cdaf10bd2713aef", + "76c01e6c851c4ebbb75392cee6efe39c", + "d102be0015e244b39b1c595ce91d61a1", + "c77ca934fe134c688eadde6035fec218", + "6e70c2e613ec42b4bc33a061061715da", + "abbbe2a017e9404dbcbf508200bbd0db", + "abaccc36cc594169b77db02b2ebeb338", + "2173dc5a2a634147abce6341e898be35", + "adb11afff90142c9bd09dbc7f1a0d1c5", + "357df50390b4435c8402361fdb2347dd", + "42e49d1f889a488b82220ac128f523a1", + "bff253bfd785437dbfe3833634923c17", + "da2eca44b4f64f87b52e9a8ac43fa160", + "f87c90bdb92448858a56abc98f311705", + "fa42eb82e5b944ed92c8e1e4282f78c2", + "e8104b737efc41c5a0615d71fe2f4d6c", + "07af6b31efdb48f28689ff413c23eb55", + "bdf39c2a2e8a4a53a85c11d6b66f48a8", + "cee3af91f7214e56bc95fbd90bf42bd7", + "224d3297cd20417d906a062c09218b7b", + "8b0e0c61d7d24ccca91e1edccc86a99f", + "9924545171344c428b7dd60f7d0c8dbd", + "b1223d95dab94ba4a8100c45857c3ef9", + "583f8afd53e845d99666666e99d6686b", + "f413b4a0bc1c4552b09ff74c0488dfc6", + "b3b377399e5b4e9397d5d109a85bfc31", + "c5fa73b8e5c14a18aff3934e3a3998ce", + "9d834b4705ad47e98da98bbc9a055050", + "8295fa5451314e20ba7487ff94c488d9", + "a69129198e784707bab17fa23c75841e", + "a0e5e22ddf6348008b1dc1f0c8b09258", + "c994bf6dcda741fab53ee2d31a088fa0", + "038c21f6e4b74cd5ac55b78a84de3177", + "10e139bc8cee42489c80ed38b69afbd1", + "aebf3a4dbd344f78b84cb60ed5b90883", + "a9f92d8a14a147a9bf7e3db30bc6c269", + "c9f6121f05b2496e87b642c3367cb281", + "0600be20dae34485b7fd3aaf6048e2c9", + "a374b54402c9479d843f30d5eb1d3af4", + "9f4589cf946a479fafe3eb505eb85f0f", + "10001578875b4d1a88669ceb334ee049", + "926c1b111ae2498bb60241a62046b349", + "3fd7e99e5a0e465f8237c3ac795598fc", + "d142c7694fe843d48efb69cee5a8d379", + "a022bffd9dc041498a7fde40da0730cc", + "41fe82b4d7d14243b4a7e4d2fc1fa576", + "2c8e3d7091984d3283403587fe8d1d4f", + "d4a89367fa5a48fb958da89c8b7bb967", + "636475475f6e4a34bf8155893d6384b9", + "d8ad739fe8084b93866f38c03c313a3a", + "e7fa725880394a43a300427f4b78d6f9", + "2c86523ea4d5464cb6350c08e925cd15", + "981878f4289e4a2ba88a37be13182325", + "0507291838064afdaa0612f7e137344a", + "53f425d3a97647958077b2322a01bcc3", + "de3afeb45f8e4775b9b55bec37bdc9f2", + "8f9ab828e3b9431ab57ad94e920618fa", + "2e1ed355944742768c18a386a7354664", + "06ba08ce49a341878609baca0f3f5538", + "c2a62d7bb77f486f8d36858a488672dd", + "db68e578f6d8407793150c2f48a9b7b9", + "91b38cbeb8ed4466b9bdd6aba89054ef", + "4390ddd534374a3d98d2d735f7d29dbd", + "d743dc1d02984af791662404a86b8cce", + "406ad8da915d4c36ad87532e7884652d", + "db2ba0d15e7c43f49b2c8f8b1f15aafb", + "acc7a9864fbd4b5186246aa395f55d0f", + "5104b0b53c2a420d9654f12cf25e3e55", + "4f66af989a9f4f48b3277a60d40ea457", + "b9abf2a5e59340dfa1016e44e083fa9c", + "e6d37796e8864a0a95b0054bdcbcbc82", + "8cbe2daaf322456faac28786a25b7dcb", + "e7fce353e9504f92b21375925733b402", + "48684bd4de50427aa5cab57dd6fe7025", + "f908a82f4d8b4c4e8c35bb7fc02dabba", + "9ac2f647993e4f81b707500fe7fa63cd", + "7bf9c542e6c84c68a04c9a6f691709af", + "eb872d3f694c45bb9297c9a37c738b06", + "966e4ec0154d47b7bf85bb58eaea6214", + "aa3c59ed265c43ca8a3c2bf12917d8fd", + "ac847f2e6efa4e5088cb72e58c59d26d", + "7993f2d2fe3a4b90a8864a99108f3d86", + "47386360e6a047c0a2398ec506cdf556", + "0f8bcacb1fee444e951b1083eed28ef1", + "f4a96f3d7fc843f3897067b3d85fc3d7", + "061348ef25ef4b96bfe148e0e840b9e0", + "bcb8e1b114ce48459f8bb1ac866b6f75", + "7a5cff18459c46a58fe9886adb818338", + "a58081de471048c59120e9bd78448972", + "d61e3e1f14e744938d52212992818ec5", + "2536dbeb6dce4c3aa1700905c35d20e0", + "0bed638168604ded86989c465fc4564f", + "b82e7822cc0c4e84852ac2fbe0f9f261", + "36ddb9594ed14a6bbb29d8643fc4e44a", + "7f52ddd7be9a45a78bceba4662d5e985", + "6fd236f1aefe4f2c8d6b5a4aa60b8d8b", + "a895bcdda57b48d48a73b7553e1861c1", + "ad3209a986974337bf10afd7686ee404", + "94cd6a9ef3bc4f8897787bb93d925d17", + "0bbf98a8c4ed4ab880307f49206e828d", + "67b0bb206ef64cb4a2336d2d5a396736", + "f6f0dc3debd148d8bcbae13a377428c5", + "260cfaccfabd4bd0b82512f6bb5986d4", + "450d82cf7683448cac6945334ae9c068", + "26e9ae325ca2442a94e02936f2c90ba3", + "2c24a443def6444a8a725d0d23d9edda", + "56d11a7b0aaa49a4bab83068f166ab38", + "5028851f9082480c8be9382d7904e03f", + "8a0dbd18fe094b9cb6991ebb1cc82f8f", + "0216e31d410941eebca42618d9c6ed64", + "75f9e359e5d343309d6603e2f73cdb14", + "2982d94a561e41ca8283181349d18770", + "4cc5fc352511401dbc4ce88c2727e5be", + "95cd432664bb4effa26233e77c693072", + "6b518ce880a94960940419502f7c1a2b", + "b6c11c998990444db71e45ed7f9f03a8", + "f00d610a35054ee98b323d9bbca3d4a9", + "4290b1c25aa7416b893cf616f3fe0026", + "a724beaae3ca4b9a869066a01e59f820", + "21deef013bf44711ac38fb14d1528972", + "ede97b2c2d8d46a19ee7a20346ad2a47", + "f539b3c6e85749799d3466df9ad2fe4b", + "d7dc40674fcf4ef28415ccb421abe09a", + "8016e285f13c403793fe8dea69dbe405", + "a90459a1164e4658b4e94c3ca27f0a49", + "b5273100a9494aeda77459b563e8aeb3", + "ffa89d92b7c84fc598f0a0a7ce28f8db", + "703bb37324604fafb616b53c4701af35", + "3fd1b8d27f4e46f8b590e3b7a1711f6a", + "c96fa78298d147ecbf97232c3f71e130", + "15b84bc102f3475d877a034f8ca06e78", + "75c90ce2877440f49ea38d31666714a6", + "a9d7de20f91e4080a5ff42c405d9d56a", + "c35104a5ca714c43859f7093835f3f5d", + "566a273b36434f5bbf1d18b11784451f", + "662d22de99f34a70a06437434f2bcbce", + "d72d47d862fd4df9a570e43a1b47679d", + "48667de2565f4c328a1581c86f14868f", + "72766cb0b675414e8118e57a8d59c657", + "341283f0354e424aa71f77d60c9728d4", + "fa819a6082c34f6faa10444f15f62868", + "3e1af7eb2d39491782da90e20c898b6a", + "b5e0bd5fb9744bebb25efb93dae0b336", + "0d376758033a4fa7bc20389b3f0138e6", + "959d909762044c99a3d5e156511e5214", + "c57a732df20044008081507e45112bac", + "8daf659848924936a4bdefb9061a8e5b", + "beec965b8b4041e19f1c3174912c3e9d", + "edee16194d7942eca9da9ad77ae9dfed", + "1adf8644607a4e788e6a9e40fcb586d7", + "efc27cac36474b2c941615f463689315", + "03d6ca44703548279c08017b47e9b29e", + "ca6f696005594623b23a425758e7d195", + "fe2d0b0e31ee438c94b25a463d400e60", + "59e517c7d73e4cb49cbdfa22f2f7f34c", + "191feb563e6f49eb98b3bade4f02c8bb", + "ede492733ddf4971bad1be522bd1472d", + "2a16922810434bcf86dcd87d7d75c666" + ] + }, + "id": "Tq09LjFtPGxt", + "outputId": "e6248062-6be9-48f9-cc38-3b46d3f2efdf", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[2023-10-15 20:07:50.807]\u001b[0m \u001b[1m/usr/bin/python3 /usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py -f /root/.local/share/jupyter/runtime/kernel-9970d1b6-3493-4bf5-96e3-1e5dedc0107f.json\u001b[0m\n", + "\u001b[32m[2023-10-15 20:07:50.812]\u001b[0m \u001b[1mPruning started: \"runs/quantumnas/\".\n", + "model:\n", + " arch:\n", + " n_wires: 4\n", + " encoder_op_list_name: 4x4_ryzxy\n", + " n_blocks: 3\n", + " n_layers_per_block: 2\n", + " q_layer_name: u3cu3_s0\n", + " down_sample_kernel_size: 6\n", + " n_front_share_blocks: 1\n", + " n_front_share_wires: 1\n", + " n_front_share_ops: 1\n", + " sampler:\n", + " strategy:\n", + " name: plain\n", + " transpile_before_run: False\n", + " load_op_list: False\n", + "dataset:\n", + " name: mnist\n", + " input_name: image\n", + " target_name: digit\n", + "optimizer:\n", + " name: adam\n", + " lr: 0.05\n", + " weight_decay: 0.0001\n", + " lambda_lr: 1e-2\n", + "run:\n", + " n_epochs: 40\n", + " bsz: 256\n", + " workers_per_gpu: 2\n", + " device: gpu\n", + "debug:\n", + " pdb: False\n", + " set_seed: True\n", + " seed: 42\n", + "callbacks: [{'callback': 'InferenceRunner', 'split': 'valid', 'subcallbacks': [{'metrics': 'CategoricalAccuracy', 'name': 'acc/valid'}, {'metrics': 'NLLError', 'name': 'loss/valid'}]}, {'callback': 'InferenceRunner', 'split': 'test', 'subcallbacks': [{'metrics': 'CategoricalAccuracy', 'name': 'acc/test'}, {'metrics': 'NLLError', 'name': 'loss/test'}]}, {'callback': 'MaxSaver', 'name': 'acc/valid'}, {'callback': 'Saver', 'max_to_keep': 10}]\n", + "qiskit:\n", + " use_qiskit: False\n", + " use_real_qc: False\n", + " backend_name: None\n", + " noise_model_name: None\n", + " basis_gates_name: None\n", + " n_shots: 8192\n", + " initial_layout: None\n", + " seed_transpiler: 42\n", + " seed_simulator: 42\n", + " optimization_level: 0\n", + " est_success_rate: False\n", + " max_jobs: 1\n", + "es:\n", + " random_search: False\n", + " population_size: 100\n", + " parent_size: 20\n", + " mutation_size: 40\n", + " mutation_prob: 0.5\n", + " crossover_size: 40\n", + " n_iterations: 5\n", + " est_success_rate: False\n", + " score_mode: loss_succ\n", + " gene_mask: None\n", + " eval:\n", + " use_noise_model: False\n", + " use_real_qc: False\n", + " bsz: qiskit_max\n", + " n_test_samples: 150\n", + "prune:\n", + " target_pruning_amount: 0.5\n", + " init_pruning_amount: 0.1\n", + " start_epoch: 0\n", + " end_epoch: 30\n", + " target_pruning_amout: 0.5\u001b[0m\n", + "\u001b[32m[2023-10-15 20:07:50.882]\u001b[0m \u001b[1mEpoch 1/10 started.\u001b[0m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b7270619be5b4e638c49ab9543ec5610", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0% 0/20 [00:00\n", + "Traceback (most recent call last):\n", + "Exception ignored in: File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " \n", + "self._shutdown_workers() File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "self._shutdown_workers() assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + "\n", + "AssertionError : can only test a child processif w.is_alive():\n", + "\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "Exception ignored in: AssertionError: can only test a child process\n", + "\n", + "Traceback (most recent call last):\n", + "Exception ignored in: File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "\n", + "Traceback (most recent call last):\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " if w.is_alive():self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + "\n", + " if w.is_alive(): File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError\n", + "AssertionError: : \n", + "can only test a child processcan only test a child processException ignored in: \n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "\n", + " Traceback (most recent call last):\n", + "self._shutdown_workers() File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():self._shutdown_workers()\n", + "\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process \n", + "if w.is_alive():Exception ignored in: \n", + "\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process' self._shutdown_workers()\n", + "AssertionError\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + ": if w.is_alive():can only test a child process\n", + "\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "\u001b[32m[2023-10-15 20:08:37.942]\u001b[0m \u001b[1mInference finished in 2.27 seconds.\u001b[0m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1c9694d5efcb47d0a615c0a11f97209c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0% 0/2 [00:00\n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()if w.is_alive():\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " \n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "\u001b[32m[2023-10-15 20:08:52.232]\u001b[0m \u001b[1mInference finished in 0.858 second.\u001b[0m\n", + "\u001b[32m[2023-10-15 20:09:02.299]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-120.pt\".\u001b[0m\n", + "\u001b[32m[2023-10-15 20:09:02.307]\u001b[0m \u001b[1m\n", + "+ [acc/test] = 66\n", + "+ [acc/valid] = 69.265\n", + "+ [acc/valid/max] = 69.507\n", + "+ [loss] = 0.93785\n", + "+ [loss/test] = 0.9535\n", + "+ [loss/valid] = 0.96044\n", + "+ [lr/lr_group0] = 0.048097\n", + "+ [nll_loss] = 0.93785\n", + "+ [prune_amount] = 0.26852\u001b[0m\n", + "\u001b[32m[2023-10-15 20:09:02.310]\u001b[0m \u001b[1mEstimated time left: 47.6 seconds.\u001b[0m\n", + "\u001b[32m[2023-10-15 20:09:02.312]\u001b[0m \u001b[1mEpoch finished in 15.9 seconds.\u001b[0m\n", + "\u001b[32m[2023-10-15 20:09:02.314]\u001b[0m \u001b[1mEpoch 7/10 started.\u001b[0m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5fa73b8e5c14a18aff3934e3a3998ce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0% 0/20 [00:00\n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + "Exception ignored in: File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "\n", + " Traceback (most recent call last):\n", + "assert self._parent_pid == os.getpid(), 'can only test a child process' File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "\n", + "AssertionError : self._shutdown_workers()can only test a child process\n", + "\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():Exception ignored in: \n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "\n", + " Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "\n", + "AssertionError File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + ": can only test a child process \n", + "if w.is_alive():Exception ignored in: \n", + "\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " Traceback (most recent call last):\n", + "assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "AssertionError : self._shutdown_workers()can only test a child process\n", + "\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: Exception ignored in: \n", + "Traceback (most recent call last):\n", + "\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "self._shutdown_workers() \n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + "self._shutdown_workers() \n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + "if w.is_alive(): \n", + "if w.is_alive(): File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " \n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError\n", + ": can only test a child processAssertionError: \n", + "can only test a child process\n", + "Exception ignored in: \n", + "Exception ignored in: Traceback (most recent call last):\n", + "\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + "self._shutdown_workers()\n", + " self._shutdown_workers() File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " \n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + "if w.is_alive():\n", + " if w.is_alive(): File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " \n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + "assert self._parent_pid == os.getpid(), 'can only test a child process' \n", + "assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError\n", + "AssertionError: : can only test a child process\n", + "can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "Exception ignored in: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n", + " self._shutdown_workers()\n", + " File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n", + " if w.is_alive():\n", + " File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n", + " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", + "AssertionError: can only test a child process\n", + "\u001b[32m[2023-10-15 20:09:21.995]\u001b[0m \u001b[1mInference finished in 3.29 seconds.\u001b[0m\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6b518ce880a94960940419502f7c1a2b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0% 0/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(params_before_prune, bins=50, alpha=0.5, label='Before pruning')\n", + "plt.hist(params_after_prune, bins=50, alpha=0.5, label='After pruning')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-aj7cjv3Sjgc", + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "*pruning ratio* of the parameters are zero after pruning." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 337 + }, + "id": "R0C6wygWSh6u", + "outputId": "24ae9746-6427-4594-baeb-235a5d528cdf", + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit depth: 13\n", + "Architecture:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circ = tq2qiskit(tq.QuantumDevice(n_wires=model.n_wires), model2.q_layer)\n", + "print(\"Circuit depth: {0}\".format(circ.depth()))\n", + "print(\"Architecture:\")\n", + "circ.draw('mpl')\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "8c9NBZ6t9JlZ" + ], + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "010a745b57464f218702d4e8e4f6a9c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01a717c12a494f9bade13620b195cfd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "01c6b75083b949afab571f99ea5f2275": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0216e31d410941eebca42618d9c6ed64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "038c21f6e4b74cd5ac55b78a84de3177": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "03d6ca44703548279c08017b47e9b29e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "0507291838064afdaa0612f7e137344a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0600be20dae34485b7fd3aaf6048e2c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a374b54402c9479d843f30d5eb1d3af4", + "IPY_MODEL_9f4589cf946a479fafe3eb505eb85f0f", + "IPY_MODEL_10001578875b4d1a88669ceb334ee049" + ], + "layout": "IPY_MODEL_926c1b111ae2498bb60241a62046b349" + } + }, + "061348ef25ef4b96bfe148e0e840b9e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "06785380fb8b43f7a83d7c18b8336dfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0ce8f98ad1c4e639a86daf88cd844a3", + "placeholder": "​", + "style": "IPY_MODEL_0e165d79e425494ca0d7c37a0e7a372b", + "value": "" + } + }, + "069ba0d8ae3346aab9b139d55a1d1705": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "06ba08ce49a341878609baca0f3f5538": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "07af6b31efdb48f28689ff413c23eb55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b0e0c61d7d24ccca91e1edccc86a99f", + "placeholder": "​", + "style": "IPY_MODEL_9924545171344c428b7dd60f7d0c8dbd", + "value": "" + } + }, + "07b5b61ee48246cca5b1de06d4bcf097": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53b7565f0f1f43108a4d945fc60806e3", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f12f039497c646bdabf7f735e7973665", + "value": 10 + } + }, + "09fcdf4a98474d218ce6c783fb8bf858": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0a45c5c6690947f9abfb5e8c13c78826": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0b4d00274f3345cc916460ab7de92d88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bbf98a8c4ed4ab880307f49206e828d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0beb88257c7844fa9b8a634d7ebeedc1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0bed638168604ded86989c465fc4564f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0c8d3178f8294b50896c13599aef3b2a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d376758033a4fa7bc20389b3f0138e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e165d79e425494ca0d7c37a0e7a372b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0e72173e1bdc4787ad92102d0a60015e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0f8bcacb1fee444e951b1083eed28ef1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a58081de471048c59120e9bd78448972", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d61e3e1f14e744938d52212992818ec5", + "value": 2 + } + }, + "0fefed8032784463ba00125da7211e45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "10001578875b4d1a88669ceb334ee049": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2c8e3d7091984d3283403587fe8d1d4f", + "placeholder": "​", + "style": "IPY_MODEL_d4a89367fa5a48fb958da89c8b7bb967", + "value": "100% 10/10 [00:01<00:00, 7.63it/s]" + } + }, + "103457d1e98b434dbbdbfac203bf9b90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1057e14d89fa4f85a2dfb4693bb5557f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bb53df44d0c740bfac7920a5164c6e70", + "placeholder": "​", + "style": "IPY_MODEL_7caef7151a9249d8a11960bee05df66b", + "value": "[loss] = 0.988, [lr/lr_group0] = 0.0497, [nll_loss] = 0.988: 100% 20/20 [00:03<00:00, 11.27it/s]" + } + }, + "10e139bc8cee42489c80ed38b69afbd1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1199ffb349584d7599d7240e26653580": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "12d65b7f3cda42b784484a31f672e379": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1330aecb41c640deb7a8a49df564f1a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "1467002494a44ff782881592c8ec91b2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8b937d390a2e431c87aa7d01de20423a", + "IPY_MODEL_7d8c09a01dbd44dc8056409402e4e9c7", + "IPY_MODEL_150543e4fb284b1481041eac10ada746" + ], + "layout": "IPY_MODEL_5002ef29438248cfb56146eafdb02ff1" + } + }, + "150543e4fb284b1481041eac10ada746": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_341ee0c0cc184a6ebbeae4209a36258f", + "placeholder": "​", + "style": "IPY_MODEL_bb68b50116cd4f1f9c15fce1770d3105", + "value": "100% 10/10 [00:02<00:00, 5.28it/s]" + } + }, + "153c07684894462088d68a6883d51e3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d739f5cb184f49b8b61ab4b4edc6646d", + "placeholder": "​", + "style": "IPY_MODEL_ce13cadf5f94487696c870f956f41147", + "value": "100% 2/2 [00:00<00:00, 2.32it/s]" + } + }, + "15b84bc102f3475d877a034f8ca06e78": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17fb1d205d124628b13ec46fcda73014": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "191feb563e6f49eb98b3bade4f02c8bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "19e04a3cf7204f38bdd130c8204799cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1adf8644607a4e788e6a9e40fcb586d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59e517c7d73e4cb49cbdfa22f2f7f34c", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_191feb563e6f49eb98b3bade4f02c8bb", + "value": 2 + } + }, + "1b13c08c7e55498686b31e6519ab618a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c9694d5efcb47d0a615c0a11f97209c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_06785380fb8b43f7a83d7c18b8336dfc", + "IPY_MODEL_e4d556d781194a018bcdb0768abf2584", + "IPY_MODEL_6b308556ac31444f86374ea813396b75" + ], + "layout": "IPY_MODEL_b3bfc0a50026417498d814455b3e6528" + } + }, + "1d975fd51c7c49b0aa19b1635b98bc2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2173dc5a2a634147abce6341e898be35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f87c90bdb92448858a56abc98f311705", + "placeholder": "​", + "style": "IPY_MODEL_fa42eb82e5b944ed92c8e1e4282f78c2", + "value": "100% 10/10 [00:01<00:00, 7.94it/s]" + } + }, + "21deef013bf44711ac38fb14d1528972": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "224d3297cd20417d906a062c09218b7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "243a82ddfc734be397b896db73d600e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ebeac59943ed4e5d9448b3e395037cbe", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f9d771a613144a18ab0271812bd3842b", + "value": 10 + } + }, + "2536dbeb6dce4c3aa1700905c35d20e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "260cfaccfabd4bd0b82512f6bb5986d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "269397ad6d234b779acf2580f3d68082": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "26e9ae325ca2442a94e02936f2c90ba3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a0dbd18fe094b9cb6991ebb1cc82f8f", + "placeholder": "​", + "style": "IPY_MODEL_0216e31d410941eebca42618d9c6ed64", + "value": "" + } + }, + "27efd00b555c4634ab5b45bdbf983109": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ce22ae9633ce44f0bed4017bbf9be9da", + "IPY_MODEL_46320ad8dfff492d8cad5e1313981592", + "IPY_MODEL_43356d3e10f34b48ac4e29428a6916d6" + ], + "layout": "IPY_MODEL_52e606a5d3a44292818324e2be53c136" + } + }, + "286cca83cfa14b57ad63fd90baafe6fe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2982d94a561e41ca8283181349d18770": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2a16922810434bcf86dcd87d7d75c666": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2a32af82ab86434fa38c169ea82d762f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ade945fa7d74bb29579e243813214fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aeb6c118f3704e35b54f95fecf97657a", + "IPY_MODEL_2f84b7d105e94f7b88cf8c53d07087fa", + "IPY_MODEL_1057e14d89fa4f85a2dfb4693bb5557f" + ], + "layout": "IPY_MODEL_507e2b30906e47418f2167cb5d2066db" + } + }, + "2c24a443def6444a8a725d0d23d9edda": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_75f9e359e5d343309d6603e2f73cdb14", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2982d94a561e41ca8283181349d18770", + "value": 10 + } + }, + "2c86523ea4d5464cb6350c08e925cd15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2e1ed355944742768c18a386a7354664", + "placeholder": "​", + "style": "IPY_MODEL_06ba08ce49a341878609baca0f3f5538", + "value": "100% 2/2 [00:00<00:00, 2.16it/s]" + } + }, + "2c8e3d7091984d3283403587fe8d1d4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e1ed355944742768c18a386a7354664": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e5859150aa24fe4992346e26b0923a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ddc20c1e23e348f69980e0c37736409e", + "IPY_MODEL_f5e24770e5e341e39b341869796db2a7", + "IPY_MODEL_153c07684894462088d68a6883d51e3b" + ], + "layout": "IPY_MODEL_572ae926714d4804bb99aa41684720c5" + } + }, + "2ef02ac3d9fe40e58bd4ac387742ce35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_50e44bcb6282447ba718d54b3eb63318", + "IPY_MODEL_bec72bacba0b4d5e9d650dfe7ca6e77e", + "IPY_MODEL_7b0ee4d02db34b2a8b1896639f54a862" + ], + "layout": "IPY_MODEL_1330aecb41c640deb7a8a49df564f1a7" + } + }, + "2f6711f9abe94245a58399b38077abfa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2f84b7d105e94f7b88cf8c53d07087fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_88ef4ca635394253b00dc164e7f9f51e", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_64748cb1cf2e4d0cbc0ff7b9813fe35b", + "value": 20 + } + }, + "3057a16ecbc6426d9075a63c65eb3788": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "32cdbee5dd984e2ab72df6e9aec7f9e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33991b02f66d42efb8ee9d048df52c8d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "33aa492ce3854ef19c3c1279a2b58a5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e5535812c2794fd99bfe3c80c8d924e4", + "IPY_MODEL_dc511da3d8034266b6bb8070e0fc4796", + "IPY_MODEL_5e0dee9c9cd74a0fb69b16a8f890bbca" + ], + "layout": "IPY_MODEL_9b68eb45f4824fe09a35fdfed01e6b84" + } + }, + "341283f0354e424aa71f77d60c9728d4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c57a732df20044008081507e45112bac", + "placeholder": "​", + "style": "IPY_MODEL_8daf659848924936a4bdefb9061a8e5b", + "value": "100% 10/10 [00:02<00:00, 7.49it/s]" + } + }, + "341ee0c0cc184a6ebbeae4209a36258f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34ab1d45802044c1a1a8d85691015681": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "354053feba474fefb583661c26bf7546": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_32cdbee5dd984e2ab72df6e9aec7f9e8", + "placeholder": "​", + "style": "IPY_MODEL_19e04a3cf7204f38bdd130c8204799cf", + "value": "" + } + }, + "357df50390b4435c8402361fdb2347dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35aefb99cd054ca184d12bec5a4de805": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_96147fdf695b4ee489c1b3f6339b746e", + "placeholder": "​", + "style": "IPY_MODEL_55f9bd1947b043e0b979594892c09e97", + "value": "100% 2/2 [00:00<00:00, 2.26it/s]" + } + }, + "36ddb9594ed14a6bbb29d8643fc4e44a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad3209a986974337bf10afd7686ee404", + "placeholder": "​", + "style": "IPY_MODEL_94cd6a9ef3bc4f8897787bb93d925d17", + "value": "" + } + }, + "38b5d9bce9924321bb7952c4ee22dfdb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_09fcdf4a98474d218ce6c783fb8bf858", + "placeholder": "​", + "style": "IPY_MODEL_9e4f6ee70e1942f6aea5ee9e34c4cc36", + "value": "" + } + }, + "3996067baf8647a3951e00a7e8fc9148": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_97bbead0378d41e2bdcd20c786a69ba5", + "placeholder": "​", + "style": "IPY_MODEL_0beb88257c7844fa9b8a634d7ebeedc1", + "value": "100% 2/2 [00:00<00:00, 2.35it/s]" + } + }, + "3bb9c81dc321483abc2b493c57b10e79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3c084f1f743f489bb3c7cf30b2dce6f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e1af7eb2d39491782da90e20c898b6a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e20d81230fe4a4ca07892d58a18f8fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3fd1b8d27f4e46f8b590e3b7a1711f6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_566a273b36434f5bbf1d18b11784451f", + "placeholder": "​", + "style": "IPY_MODEL_662d22de99f34a70a06437434f2bcbce", + "value": "[loss] = 0.961, [lr/lr_group0] = 0.044, [nll_loss] = 0.961: 100% 20/20 [00:03<00:00, 11.76it/s]" + } + }, + "3fd7e99e5a0e465f8237c3ac795598fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "402d70f3ae3c484b80e9885ae2ed1bae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "406ad8da915d4c36ad87532e7884652d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41b6b4ecd14340beba715f7eff584c90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "41d8c0c48e9e45468fb80763df83eaf2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "41fe82b4d7d14243b4a7e4d2fc1fa576": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4290b1c25aa7416b893cf616f3fe0026": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8016e285f13c403793fe8dea69dbe405", + "placeholder": "​", + "style": "IPY_MODEL_a90459a1164e4658b4e94c3ca27f0a49", + "value": "100% 2/2 [00:00<00:00, 3.24it/s]" + } + }, + "42e49d1f889a488b82220ac128f523a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "43356d3e10f34b48ac4e29428a6916d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f5d6456620a4c1089cc854e154cc9b4", + "placeholder": "​", + "style": "IPY_MODEL_64e22301d6e44864b4f751ad6c115858", + "value": "[loss] = 0.926, [lr/lr_group0] = 0.0493, [nll_loss] = 0.926: 100% 20/20 [00:03<00:00, 10.11it/s]" + } + }, + "4374447a37e449b09111aecb5e216f99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4390ddd534374a3d98d2d735f7d29dbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f66af989a9f4f48b3277a60d40ea457", + "placeholder": "​", + "style": "IPY_MODEL_b9abf2a5e59340dfa1016e44e083fa9c", + "value": "[loss] = 0.948, [lr/lr_group0] = 0.0463, [nll_loss] = 0.948: 100% 20/20 [00:03<00:00, 7.93it/s]" + } + }, + "44954230ed0a4fe9a416604c59f6e58e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a29fe7dd04f4b9f95070a39f0cf2e23", + "placeholder": "​", + "style": "IPY_MODEL_df57df5495924f95a2c2e3f8855dd121", + "value": "[loss] = 0.955, [lr/lr_group0] = 0.05, [nll_loss] = 0.955: 100% 20/20 [00:05<00:00, 5.83it/s]" + } + }, + "450d82cf7683448cac6945334ae9c068": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_26e9ae325ca2442a94e02936f2c90ba3", + "IPY_MODEL_2c24a443def6444a8a725d0d23d9edda", + "IPY_MODEL_56d11a7b0aaa49a4bab83068f166ab38" + ], + "layout": "IPY_MODEL_5028851f9082480c8be9382d7904e03f" + } + }, + "46320ad8dfff492d8cad5e1313981592": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aba185ddea19446a816c4a865cd26b31", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9530de20144c4cb3901561e0d725fad2", + "value": 20 + } + }, + "47386360e6a047c0a2398ec506cdf556": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bcb8e1b114ce48459f8bb1ac866b6f75", + "placeholder": "​", + "style": "IPY_MODEL_7a5cff18459c46a58fe9886adb818338", + "value": "" + } + }, + "48157fc41bd64f8cbd1dc3e9863eca97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48667de2565f4c328a1581c86f14868f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3e1af7eb2d39491782da90e20c898b6a", + "placeholder": "​", + "style": "IPY_MODEL_b5e0bd5fb9744bebb25efb93dae0b336", + "value": "" + } + }, + "48684bd4de50427aa5cab57dd6fe7025": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa3c59ed265c43ca8a3c2bf12917d8fd", + "placeholder": "​", + "style": "IPY_MODEL_ac847f2e6efa4e5088cb72e58c59d26d", + "value": "100% 10/10 [00:02<00:00, 5.22it/s]" + } + }, + "4abd54da2cb64417843d23e6f83f97d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef1fdca48c0448748eca0e1fba68779b", + "IPY_MODEL_bffb3950a3614e22b2f8d5213a70d89d", + "IPY_MODEL_4c09b008802e4bbfad8b698355056f14" + ], + "layout": "IPY_MODEL_402d70f3ae3c484b80e9885ae2ed1bae" + } + }, + "4c09b008802e4bbfad8b698355056f14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d102be0015e244b39b1c595ce91d61a1", + "placeholder": "​", + "style": "IPY_MODEL_c77ca934fe134c688eadde6035fec218", + "value": "[loss] = 0.938, [lr/lr_group0] = 0.0481, [nll_loss] = 0.938: 100% 20/20 [00:03<00:00, 11.76it/s]" + } + }, + "4c0a81679d06428a8edb3d5bb00f5849": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_269397ad6d234b779acf2580f3d68082", + "placeholder": "​", + "style": "IPY_MODEL_549a22d7772149b7a924b2e924ab9ec1", + "value": "" + } + }, + "4cc5fc352511401dbc4ce88c2727e5be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d87f28dce814e9d8a4abf84e30d02b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f66af989a9f4f48b3277a60d40ea457": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5002ef29438248cfb56146eafdb02ff1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "5028851f9082480c8be9382d7904e03f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "503680c2cf6e43589d795cdb3a8cb949": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "507e2b30906e47418f2167cb5d2066db": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "50e44bcb6282447ba718d54b3eb63318": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4374447a37e449b09111aecb5e216f99", + "placeholder": "​", + "style": "IPY_MODEL_801c8d0b42e14241b6be8a30e2cd9aac", + "value": "" + } + }, + "5104b0b53c2a420d9654f12cf25e3e55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "52e606a5d3a44292818324e2be53c136": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "53b7565f0f1f43108a4d945fc60806e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53f425d3a97647958077b2322a01bcc3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "549a22d7772149b7a924b2e924ab9ec1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "55f9bd1947b043e0b979594892c09e97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "566a273b36434f5bbf1d18b11784451f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "56d11a7b0aaa49a4bab83068f166ab38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4cc5fc352511401dbc4ce88c2727e5be", + "placeholder": "​", + "style": "IPY_MODEL_95cd432664bb4effa26233e77c693072", + "value": "100% 10/10 [00:03<00:00, 4.10it/s]" + } + }, + "572ae926714d4804bb99aa41684720c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "583f8afd53e845d99666666e99d6686b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59e517c7d73e4cb49cbdfa22f2f7f34c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d9b0a399157483bb79c0936347df4dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e0dee9c9cd74a0fb69b16a8f890bbca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b30f7e59474d4436acad24f4c96a1e1b", + "placeholder": "​", + "style": "IPY_MODEL_3057a16ecbc6426d9075a63c65eb3788", + "value": "[loss] = 0.968, [lr/lr_group0] = 0.0488, [nll_loss] = 0.968: 100% 20/20 [00:04<00:00, 5.94it/s]" + } + }, + "627f1f3b5a1e40d5a83b1046e22c0167": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "636475475f6e4a34bf8155893d6384b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d8ad739fe8084b93866f38c03c313a3a", + "IPY_MODEL_e7fa725880394a43a300427f4b78d6f9", + "IPY_MODEL_2c86523ea4d5464cb6350c08e925cd15" + ], + "layout": "IPY_MODEL_981878f4289e4a2ba88a37be13182325" + } + }, + "643044d3241e42acac6caa904c427672": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c084f1f743f489bb3c7cf30b2dce6f3", + "placeholder": "​", + "style": "IPY_MODEL_3e20d81230fe4a4ca07892d58a18f8fd", + "value": "100% 10/10 [00:02<00:00, 5.79it/s]" + } + }, + "64748cb1cf2e4d0cbc0ff7b9813fe35b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64e22301d6e44864b4f751ad6c115858": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6538daa9bb3b498d96332c98b1f7d723": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65fc01a8608846d185bac6a498c4694c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_103457d1e98b434dbbdbfac203bf9b90", + "placeholder": "​", + "style": "IPY_MODEL_1d975fd51c7c49b0aa19b1635b98bc2f", + "value": "" + } + }, + "662d22de99f34a70a06437434f2bcbce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "67b0bb206ef64cb4a2336d2d5a396736": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "689257a51152408db4d93f98d0e62a78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "68ed37e451e0498f9ed9fd2ea2a5531b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6a39c54e39b048cb86056b70fc0fd224": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6b308556ac31444f86374ea813396b75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0fefed8032784463ba00125da7211e45", + "placeholder": "​", + "style": "IPY_MODEL_17fb1d205d124628b13ec46fcda73014", + "value": "100% 2/2 [00:00<00:00, 1.81it/s]" + } + }, + "6b518ce880a94960940419502f7c1a2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b6c11c998990444db71e45ed7f9f03a8", + "IPY_MODEL_f00d610a35054ee98b323d9bbca3d4a9", + "IPY_MODEL_4290b1c25aa7416b893cf616f3fe0026" + ], + "layout": "IPY_MODEL_a724beaae3ca4b9a869066a01e59f820" + } + }, + "6cf3bea675b040aabf28a88694280385": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b4d00274f3345cc916460ab7de92d88", + "placeholder": "​", + "style": "IPY_MODEL_e5558cda2ad74becb5a20cff6b1195b8", + "value": "" + } + }, + "6d4e5f40efd64ac5b6d69754472ccf36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6d856a27234c4437b3ec49ca4eeca36d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0c8d3178f8294b50896c13599aef3b2a", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fae629f7891846c6bd4eb39795053d6b", + "value": 20 + } + }, + "6de2285eac56405bb60a3e3c7f4c21d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e5bc2858bc342fb95383ec05ec1ed50": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "6e70c2e613ec42b4bc33a061061715da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_abbbe2a017e9404dbcbf508200bbd0db", + "IPY_MODEL_abaccc36cc594169b77db02b2ebeb338", + "IPY_MODEL_2173dc5a2a634147abce6341e898be35" + ], + "layout": "IPY_MODEL_adb11afff90142c9bd09dbc7f1a0d1c5" + } + }, + "6fb2cdd8154940eabdcc7a470f26d37e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6fd236f1aefe4f2c8d6b5a4aa60b8d8b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f6f0dc3debd148d8bcbae13a377428c5", + "placeholder": "​", + "style": "IPY_MODEL_260cfaccfabd4bd0b82512f6bb5986d4", + "value": "[loss] = 0.993, [lr/lr_group0] = 0.0452, [nll_loss] = 0.993: 100% 20/20 [00:03<00:00, 8.74it/s]" + } + }, + "703bb37324604fafb616b53c4701af35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a9d7de20f91e4080a5ff42c405d9d56a", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c35104a5ca714c43859f7093835f3f5d", + "value": 20 + } + }, + "72766cb0b675414e8118e57a8d59c657": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d376758033a4fa7bc20389b3f0138e6", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_959d909762044c99a3d5e156511e5214", + "value": 10 + } + }, + "75c90ce2877440f49ea38d31666714a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "75f9e359e5d343309d6603e2f73cdb14": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "76c01e6c851c4ebbb75392cee6efe39c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "78f3c6c9183649c1804a9169bcbd4fe2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7993f2d2fe3a4b90a8864a99108f3d86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_47386360e6a047c0a2398ec506cdf556", + "IPY_MODEL_0f8bcacb1fee444e951b1083eed28ef1", + "IPY_MODEL_f4a96f3d7fc843f3897067b3d85fc3d7" + ], + "layout": "IPY_MODEL_061348ef25ef4b96bfe148e0e840b9e0" + } + }, + "79f61439f4db45e38c5d3ea1709fa786": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e5b60e57eac84a8daec873bdf663ff78", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e40f2266ce194eabbf6bde90c195cc3f", + "value": 10 + } + }, + "7a5cff18459c46a58fe9886adb818338": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b0ee4d02db34b2a8b1896639f54a862": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ba2c117a55784623af4b49a92efa9451", + "placeholder": "​", + "style": "IPY_MODEL_d855437dc30d4c1db0ab25854763140c", + "value": "100% 2/2 [00:00<00:00, 1.54it/s]" + } + }, + "7bf9c542e6c84c68a04c9a6f691709af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7caef7151a9249d8a11960bee05df66b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7d8c09a01dbd44dc8056409402e4e9c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b9653be5f6554faab6521f15d632fe60", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_41b6b4ecd14340beba715f7eff584c90", + "value": 10 + } + }, + "7ed7914804514338b5142eaca84e8e4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7f52ddd7be9a45a78bceba4662d5e985": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0bbf98a8c4ed4ab880307f49206e828d", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_67b0bb206ef64cb4a2336d2d5a396736", + "value": 20 + } + }, + "8016e285f13c403793fe8dea69dbe405": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "801c8d0b42e14241b6be8a30e2cd9aac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8295fa5451314e20ba7487ff94c488d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_10e139bc8cee42489c80ed38b69afbd1", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aebf3a4dbd344f78b84cb60ed5b90883", + "value": 20 + } + }, + "8328a3bfda174305956041df2dccb259": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "882aaa8ea30149248018563b95d64cef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6cf3bea675b040aabf28a88694280385", + "IPY_MODEL_79f61439f4db45e38c5d3ea1709fa786", + "IPY_MODEL_fd025febe00e4b06a7c9e6204fc08b50" + ], + "layout": "IPY_MODEL_d9b9fd061ebc4f6f9d9587d17062f3f6" + } + }, + "88ef4ca635394253b00dc164e7f9f51e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8913810f447b471e9eb96e11a64c18eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a0dbd18fe094b9cb6991ebb1cc82f8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b0e0c61d7d24ccca91e1edccc86a99f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b937d390a2e431c87aa7d01de20423a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f384cc0c9bd4f1c96b58b22b094446e", + "placeholder": "​", + "style": "IPY_MODEL_503680c2cf6e43589d795cdb3a8cb949", + "value": "" + } + }, + "8bdd09525f45448fa9eec393b9e06082": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5d9b0a399157483bb79c0936347df4dd", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f1e2794dd40541399316d77d2ae30c40", + "value": 10 + } + }, + "8cb378b74173480da6069536f3cc752b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8cbe2daaf322456faac28786a25b7dcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9ac2f647993e4f81b707500fe7fa63cd", + "placeholder": "​", + "style": "IPY_MODEL_7bf9c542e6c84c68a04c9a6f691709af", + "value": "" + } + }, + "8daf659848924936a4bdefb9061a8e5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8f5d6456620a4c1089cc854e154cc9b4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f9ab828e3b9431ab57ad94e920618fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "902476f4033b4c2e9ca49aaef966e117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_beec379e14b44b0aaf26bf4fd763c835", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_069ba0d8ae3346aab9b139d55a1d1705", + "value": 20 + } + }, + "91381de219ac47739b8e0907e487583e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91b38cbeb8ed4466b9bdd6aba89054ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_acc7a9864fbd4b5186246aa395f55d0f", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5104b0b53c2a420d9654f12cf25e3e55", + "value": 20 + } + }, + "926c1b111ae2498bb60241a62046b349": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "94cd6a9ef3bc4f8897787bb93d925d17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9530de20144c4cb3901561e0d725fad2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "959d909762044c99a3d5e156511e5214": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "95cd432664bb4effa26233e77c693072": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "96147fdf695b4ee489c1b3f6339b746e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "966e4ec0154d47b7bf85bb58eaea6214": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "972e0f1d733b4993a4cae82fc47e124d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6de2285eac56405bb60a3e3c7f4c21d9", + "placeholder": "​", + "style": "IPY_MODEL_68ed37e451e0498f9ed9fd2ea2a5531b", + "value": "" + } + }, + "9738d0ac2d50413b8b45fd30d3896e02": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_972e0f1d733b4993a4cae82fc47e124d", + "IPY_MODEL_8bdd09525f45448fa9eec393b9e06082", + "IPY_MODEL_d7bdad9f9355485695fdbc6f2731fad4" + ], + "layout": "IPY_MODEL_33991b02f66d42efb8ee9d048df52c8d" + } + }, + "97bbead0378d41e2bdcd20c786a69ba5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "981878f4289e4a2ba88a37be13182325": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "9924545171344c428b7dd60f7d0c8dbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "992c199e1c85444c9727a0bd2ae5dbd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_354053feba474fefb583661c26bf7546", + "IPY_MODEL_aaa208280ffa4e9ba9aa2dfa9a3e5236", + "IPY_MODEL_35aefb99cd054ca184d12bec5a4de805" + ], + "layout": "IPY_MODEL_6e5bc2858bc342fb95383ec05ec1ed50" + } + }, + "9a29fe7dd04f4b9f95070a39f0cf2e23": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ac2f647993e4f81b707500fe7fa63cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b68eb45f4824fe09a35fdfed01e6b84": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "9d834b4705ad47e98da98bbc9a055050": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c994bf6dcda741fab53ee2d31a088fa0", + "placeholder": "​", + "style": "IPY_MODEL_038c21f6e4b74cd5ac55b78a84de3177", + "value": "" + } + }, + "9d87317235394b3fa4b7b44b94713d99": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6538daa9bb3b498d96332c98b1f7d723", + "placeholder": "​", + "style": "IPY_MODEL_2f6711f9abe94245a58399b38077abfa", + "value": "" + } + }, + "9e4f6ee70e1942f6aea5ee9e34c4cc36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9f384cc0c9bd4f1c96b58b22b094446e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9f4589cf946a479fafe3eb505eb85f0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a022bffd9dc041498a7fde40da0730cc", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_41fe82b4d7d14243b4a7e4d2fc1fa576", + "value": 10 + } + }, + "9ffacb579af6479392fb6d9aa83922bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4c0a81679d06428a8edb3d5bb00f5849", + "IPY_MODEL_07b5b61ee48246cca5b1de06d4bcf097", + "IPY_MODEL_c43d55b254b443cebd61b8ad84bca9ac" + ], + "layout": "IPY_MODEL_627f1f3b5a1e40d5a83b1046e22c0167" + } + }, + "a022bffd9dc041498a7fde40da0730cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0e5e22ddf6348008b1dc1f0c8b09258": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "a1258da98bbc487d8a2410695c982508": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc842e0a59df48169437db4b2106e524", + "placeholder": "​", + "style": "IPY_MODEL_6fb2cdd8154940eabdcc7a470f26d37e", + "value": "[loss] = 0.975, [lr/lr_group0] = 0.0499, [nll_loss] = 0.975: 100% 20/20 [00:03<00:00, 7.75it/s]" + } + }, + "a374b54402c9479d843f30d5eb1d3af4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3fd7e99e5a0e465f8237c3ac795598fc", + "placeholder": "​", + "style": "IPY_MODEL_d142c7694fe843d48efb69cee5a8d379", + "value": "" + } + }, + "a3f22c44214940ff9cdaf10bd2713aef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a58081de471048c59120e9bd78448972": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a69129198e784707bab17fa23c75841e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a9f92d8a14a147a9bf7e3db30bc6c269", + "placeholder": "​", + "style": "IPY_MODEL_c9f6121f05b2496e87b642c3367cb281", + "value": "[loss] = 0.971, [lr/lr_group0] = 0.0473, [nll_loss] = 0.971: 100% 20/20 [00:03<00:00, 12.01it/s]" + } + }, + "a724beaae3ca4b9a869066a01e59f820": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "a73a24f103a4473d8f91f7ee25b96e7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "a895bcdda57b48d48a73b7553e1861c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "a8b986636cbc4ddc8fabd880897db568": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a90459a1164e4658b4e94c3ca27f0a49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a9d7de20f91e4080a5ff42c405d9d56a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a9f92d8a14a147a9bf7e3db30bc6c269": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa3c59ed265c43ca8a3c2bf12917d8fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aaa208280ffa4e9ba9aa2dfa9a3e5236": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f93e99b23ab24f359c2dea674611dbb4", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3bb9c81dc321483abc2b493c57b10e79", + "value": 2 + } + }, + "aba185ddea19446a816c4a865cd26b31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "abaccc36cc594169b77db02b2ebeb338": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bff253bfd785437dbfe3833634923c17", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_da2eca44b4f64f87b52e9a8ac43fa160", + "value": 10 + } + }, + "abbbe2a017e9404dbcbf508200bbd0db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_357df50390b4435c8402361fdb2347dd", + "placeholder": "​", + "style": "IPY_MODEL_42e49d1f889a488b82220ac128f523a1", + "value": "" + } + }, + "ac847f2e6efa4e5088cb72e58c59d26d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "acc7a9864fbd4b5186246aa395f55d0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad3209a986974337bf10afd7686ee404": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "adb11afff90142c9bd09dbc7f1a0d1c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "ae64800630624d06b600aa63200a7753": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aeb6c118f3704e35b54f95fecf97657a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8cb378b74173480da6069536f3cc752b", + "placeholder": "​", + "style": "IPY_MODEL_f015c88c2412411f854871c14388cc5d", + "value": "" + } + }, + "aebf3a4dbd344f78b84cb60ed5b90883": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b1223d95dab94ba4a8100c45857c3ef9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b30f7e59474d4436acad24f4c96a1e1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3b377399e5b4e9397d5d109a85bfc31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b3bfc0a50026417498d814455b3e6528": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "b4eb50d852fd46c9b675caab8070ec36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "b5273100a9494aeda77459b563e8aeb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ffa89d92b7c84fc598f0a0a7ce28f8db", + "IPY_MODEL_703bb37324604fafb616b53c4701af35", + "IPY_MODEL_3fd1b8d27f4e46f8b590e3b7a1711f6a" + ], + "layout": "IPY_MODEL_c96fa78298d147ecbf97232c3f71e130" + } + }, + "b5e0bd5fb9744bebb25efb93dae0b336": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b6c11c998990444db71e45ed7f9f03a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_21deef013bf44711ac38fb14d1528972", + "placeholder": "​", + "style": "IPY_MODEL_ede97b2c2d8d46a19ee7a20346ad2a47", + "value": "" + } + }, + "b7270619be5b4e638c49ab9543ec5610": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_65fc01a8608846d185bac6a498c4694c", + "IPY_MODEL_902476f4033b4c2e9ca49aaef966e117", + "IPY_MODEL_44954230ed0a4fe9a416604c59f6e58e" + ], + "layout": "IPY_MODEL_d60ba45ddde4424c96331d083a91a187" + } + }, + "b82e7822cc0c4e84852ac2fbe0f9f261": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_36ddb9594ed14a6bbb29d8643fc4e44a", + "IPY_MODEL_7f52ddd7be9a45a78bceba4662d5e985", + "IPY_MODEL_6fd236f1aefe4f2c8d6b5a4aa60b8d8b" + ], + "layout": "IPY_MODEL_a895bcdda57b48d48a73b7553e1861c1" + } + }, + "b9653be5f6554faab6521f15d632fe60": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b9abf2a5e59340dfa1016e44e083fa9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ba2c117a55784623af4b49a92efa9451": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb53df44d0c740bfac7920a5164c6e70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb68b50116cd4f1f9c15fce1770d3105": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bcb8e1b114ce48459f8bb1ac866b6f75": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdf39c2a2e8a4a53a85c11d6b66f48a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b1223d95dab94ba4a8100c45857c3ef9", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_583f8afd53e845d99666666e99d6686b", + "value": 2 + } + }, + "bec72bacba0b4d5e9d650dfe7ca6e77e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b13c08c7e55498686b31e6519ab618a", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_689257a51152408db4d93f98d0e62a78", + "value": 2 + } + }, + "beec379e14b44b0aaf26bf4fd763c835": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "beec965b8b4041e19f1c3174912c3e9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_edee16194d7942eca9da9ad77ae9dfed", + "IPY_MODEL_1adf8644607a4e788e6a9e40fcb586d7", + "IPY_MODEL_efc27cac36474b2c941615f463689315" + ], + "layout": "IPY_MODEL_03d6ca44703548279c08017b47e9b29e" + } + }, + "bff253bfd785437dbfe3833634923c17": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bffb3950a3614e22b2f8d5213a70d89d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a3f22c44214940ff9cdaf10bd2713aef", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_76c01e6c851c4ebbb75392cee6efe39c", + "value": 20 + } + }, + "c2a62d7bb77f486f8d36858a488672dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_db68e578f6d8407793150c2f48a9b7b9", + "IPY_MODEL_91b38cbeb8ed4466b9bdd6aba89054ef", + "IPY_MODEL_4390ddd534374a3d98d2d735f7d29dbd" + ], + "layout": "IPY_MODEL_d743dc1d02984af791662404a86b8cce" + } + }, + "c35104a5ca714c43859f7093835f3f5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c43d55b254b443cebd61b8ad84bca9ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2a32af82ab86434fa38c169ea82d762f", + "placeholder": "​", + "style": "IPY_MODEL_e30a841229f3449cb0bab37a0ac662ee", + "value": "100% 10/10 [00:02<00:00, 6.36it/s]" + } + }, + "c4c7988172154020abf7ca546250bd45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c57a732df20044008081507e45112bac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5fa73b8e5c14a18aff3934e3a3998ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9d834b4705ad47e98da98bbc9a055050", + "IPY_MODEL_8295fa5451314e20ba7487ff94c488d9", + "IPY_MODEL_a69129198e784707bab17fa23c75841e" + ], + "layout": "IPY_MODEL_a0e5e22ddf6348008b1dc1f0c8b09258" + } + }, + "c77ca934fe134c688eadde6035fec218": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c96fa78298d147ecbf97232c3f71e130": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "c994bf6dcda741fab53ee2d31a088fa0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c9f6121f05b2496e87b642c3367cb281": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ca6f696005594623b23a425758e7d195": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce13cadf5f94487696c870f956f41147": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ce22ae9633ce44f0bed4017bbf9be9da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91381de219ac47739b8e0907e487583e", + "placeholder": "​", + "style": "IPY_MODEL_0a45c5c6690947f9abfb5e8c13c78826", + "value": "" + } + }, + "ceb7e9da20e0440382d80bbe23580848": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f4c1939a308544b8aad47c011eaeb07b", + "IPY_MODEL_6d856a27234c4437b3ec49ca4eeca36d", + "IPY_MODEL_a1258da98bbc487d8a2410695c982508" + ], + "layout": "IPY_MODEL_1199ffb349584d7599d7240e26653580" + } + }, + "cee3af91f7214e56bc95fbd90bf42bd7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f413b4a0bc1c4552b09ff74c0488dfc6", + "placeholder": "​", + "style": "IPY_MODEL_b3b377399e5b4e9397d5d109a85bfc31", + "value": "100% 2/2 [00:00<00:00, 1.25it/s]" + } + }, + "d102be0015e244b39b1c595ce91d61a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d142c7694fe843d48efb69cee5a8d379": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d3320caa762546d5b68f862bfda1a610": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9d87317235394b3fa4b7b44b94713d99", + "IPY_MODEL_243a82ddfc734be397b896db73d600e8", + "IPY_MODEL_643044d3241e42acac6caa904c427672" + ], + "layout": "IPY_MODEL_a73a24f103a4473d8f91f7ee25b96e7c" + } + }, + "d39f14ae61084b55abb92b9d6ac7706e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d4a89367fa5a48fb958da89c8b7bb967": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d60ba45ddde4424c96331d083a91a187": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "d61e3e1f14e744938d52212992818ec5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d72d47d862fd4df9a570e43a1b47679d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_48667de2565f4c328a1581c86f14868f", + "IPY_MODEL_72766cb0b675414e8118e57a8d59c657", + "IPY_MODEL_341283f0354e424aa71f77d60c9728d4" + ], + "layout": "IPY_MODEL_fa819a6082c34f6faa10444f15f62868" + } + }, + "d739f5cb184f49b8b61ab4b4edc6646d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d743dc1d02984af791662404a86b8cce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "d7bdad9f9355485695fdbc6f2731fad4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d87f28dce814e9d8a4abf84e30d02b5", + "placeholder": "​", + "style": "IPY_MODEL_01c6b75083b949afab571f99ea5f2275", + "value": "100% 10/10 [00:01<00:00, 7.65it/s]" + } + }, + "d7dc40674fcf4ef28415ccb421abe09a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d855437dc30d4c1db0ab25854763140c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d8ad739fe8084b93866f38c03c313a3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0507291838064afdaa0612f7e137344a", + "placeholder": "​", + "style": "IPY_MODEL_53f425d3a97647958077b2322a01bcc3", + "value": "" + } + }, + "d9b9fd061ebc4f6f9d9587d17062f3f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "da2eca44b4f64f87b52e9a8ac43fa160": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "db2ba0d15e7c43f49b2c8f8b1f15aafb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db68e578f6d8407793150c2f48a9b7b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_406ad8da915d4c36ad87532e7884652d", + "placeholder": "​", + "style": "IPY_MODEL_db2ba0d15e7c43f49b2c8f8b1f15aafb", + "value": "" + } + }, + "dc511da3d8034266b6bb8070e0fc4796": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_78f3c6c9183649c1804a9169bcbd4fe2", + "max": 20, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d39f14ae61084b55abb92b9d6ac7706e", + "value": 20 + } + }, + "dc842e0a59df48169437db4b2106e524": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ddc20c1e23e348f69980e0c37736409e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8913810f447b471e9eb96e11a64c18eb", + "placeholder": "​", + "style": "IPY_MODEL_12d65b7f3cda42b784484a31f672e379", + "value": "" + } + }, + "de3afeb45f8e4775b9b55bec37bdc9f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de534eba45b74551a7d8ba5e90971f12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38b5d9bce9924321bb7952c4ee22dfdb", + "IPY_MODEL_ec0105fb3abe4f4db387b4a98d38cc71", + "IPY_MODEL_3996067baf8647a3951e00a7e8fc9148" + ], + "layout": "IPY_MODEL_b4eb50d852fd46c9b675caab8070ec36" + } + }, + "df57df5495924f95a2c2e3f8855dd121": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e0ce8f98ad1c4e639a86daf88cd844a3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e30a841229f3449cb0bab37a0ac662ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e40f2266ce194eabbf6bde90c195cc3f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e4d556d781194a018bcdb0768abf2584": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_286cca83cfa14b57ad63fd90baafe6fe", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0e72173e1bdc4787ad92102d0a60015e", + "value": 2 + } + }, + "e5535812c2794fd99bfe3c80c8d924e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_010a745b57464f218702d4e8e4f6a9c1", + "placeholder": "​", + "style": "IPY_MODEL_41d8c0c48e9e45468fb80763df83eaf2", + "value": "" + } + }, + "e5558cda2ad74becb5a20cff6b1195b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e5b60e57eac84a8daec873bdf663ff78": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6d37796e8864a0a95b0054bdcbcbc82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8cbe2daaf322456faac28786a25b7dcb", + "IPY_MODEL_e7fce353e9504f92b21375925733b402", + "IPY_MODEL_48684bd4de50427aa5cab57dd6fe7025" + ], + "layout": "IPY_MODEL_f908a82f4d8b4c4e8c35bb7fc02dabba" + } + }, + "e7fa725880394a43a300427f4b78d6f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de3afeb45f8e4775b9b55bec37bdc9f2", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8f9ab828e3b9431ab57ad94e920618fa", + "value": 2 + } + }, + "e7fce353e9504f92b21375925733b402": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb872d3f694c45bb9297c9a37c738b06", + "max": 10, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_966e4ec0154d47b7bf85bb58eaea6214", + "value": 10 + } + }, + "e8104b737efc41c5a0615d71fe2f4d6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07af6b31efdb48f28689ff413c23eb55", + "IPY_MODEL_bdf39c2a2e8a4a53a85c11d6b66f48a8", + "IPY_MODEL_cee3af91f7214e56bc95fbd90bf42bd7" + ], + "layout": "IPY_MODEL_224d3297cd20417d906a062c09218b7b" + } + }, + "eb872d3f694c45bb9297c9a37c738b06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebeac59943ed4e5d9448b3e395037cbe": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec0105fb3abe4f4db387b4a98d38cc71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8328a3bfda174305956041df2dccb259", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6d4e5f40efd64ac5b6d69754472ccf36", + "value": 2 + } + }, + "ede492733ddf4971bad1be522bd1472d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ede97b2c2d8d46a19ee7a20346ad2a47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "edee16194d7942eca9da9ad77ae9dfed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ca6f696005594623b23a425758e7d195", + "placeholder": "​", + "style": "IPY_MODEL_fe2d0b0e31ee438c94b25a463d400e60", + "value": "" + } + }, + "ef1fdca48c0448748eca0e1fba68779b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a39c54e39b048cb86056b70fc0fd224", + "placeholder": "​", + "style": "IPY_MODEL_7ed7914804514338b5142eaca84e8e4c", + "value": "" + } + }, + "efc27cac36474b2c941615f463689315": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ede492733ddf4971bad1be522bd1472d", + "placeholder": "​", + "style": "IPY_MODEL_2a16922810434bcf86dcd87d7d75c666", + "value": "100% 2/2 [00:00<00:00, 1.55it/s]" + } + }, + "f00d610a35054ee98b323d9bbca3d4a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f539b3c6e85749799d3466df9ad2fe4b", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d7dc40674fcf4ef28415ccb421abe09a", + "value": 2 + } + }, + "f015c88c2412411f854871c14388cc5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f12f039497c646bdabf7f735e7973665": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f1e2794dd40541399316d77d2ae30c40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f413b4a0bc1c4552b09ff74c0488dfc6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f4a96f3d7fc843f3897067b3d85fc3d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2536dbeb6dce4c3aa1700905c35d20e0", + "placeholder": "​", + "style": "IPY_MODEL_0bed638168604ded86989c465fc4564f", + "value": "100% 2/2 [00:00<00:00, 1.51it/s]" + } + }, + "f4c1939a308544b8aad47c011eaeb07b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48157fc41bd64f8cbd1dc3e9863eca97", + "placeholder": "​", + "style": "IPY_MODEL_01a717c12a494f9bade13620b195cfd9", + "value": "" + } + }, + "f539b3c6e85749799d3466df9ad2fe4b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f5e24770e5e341e39b341869796db2a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c4c7988172154020abf7ca546250bd45", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ae64800630624d06b600aa63200a7753", + "value": 2 + } + }, + "f6f0dc3debd148d8bcbae13a377428c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f87c90bdb92448858a56abc98f311705": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f908a82f4d8b4c4e8c35bb7fc02dabba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "f93e99b23ab24f359c2dea674611dbb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9d771a613144a18ab0271812bd3842b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fa42eb82e5b944ed92c8e1e4282f78c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fa819a6082c34f6faa10444f15f62868": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "0" + } + }, + "fae629f7891846c6bd4eb39795053d6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fd025febe00e4b06a7c9e6204fc08b50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a8b986636cbc4ddc8fabd880897db568", + "placeholder": "​", + "style": "IPY_MODEL_34ab1d45802044c1a1a8d85691015681", + "value": "100% 10/10 [00:01<00:00, 7.63it/s]" + } + }, + "fe2d0b0e31ee438c94b25a463d400e60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ffa89d92b7c84fc598f0a0a7ce28f8db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_15b84bc102f3475d877a034f8ca06e78", + "placeholder": "​", + "style": "IPY_MODEL_75c90ce2877440f49ea38d31666714a6", + "value": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From e81534105fa4d4971f9f4f4d5a88e0527076e102 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 15 Oct 2023 18:49:46 -0400 Subject: [PATCH 023/106] add layers to docs --- docs/source/api_layers.rst | 29 +++++++++++++++++++++++++++++ docs/source/index.rst | 1 + 2 files changed, 30 insertions(+) create mode 100644 docs/source/api_layers.rst diff --git a/docs/source/api_layers.rst b/docs/source/api_layers.rst new file mode 100644 index 00000000..18a6753c --- /dev/null +++ b/docs/source/api_layers.rst @@ -0,0 +1,29 @@ +torchquantum.layers +====================== + +.. currentmodule:: torchquantum.layer + +Layers +--------- +.. autosummary:: + :toctree: generated + :template: classtemplate_controlflow.rst + + + QuantumModuleFromOps + TrainableOpAll + ClassicalInOpAll + FixedOpAll + TwoQAll + RandomLayer + RandomLayerAllTypes + Op1QAllLayer + RandomOp1All + Op2QAllLayer + Op2QButterflyLayer + Op2QDenseLayer + CXLayer + CXCXCXLayer + SWAPSWAPLayer + RXYZCXLayer0 + QFTLayer diff --git a/docs/source/index.rst b/docs/source/index.rst index a1a4f08a..24f29897 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -5,6 +5,7 @@ api_torchquantum api_functional api_operators + api_layers .. toctree:: :maxdepth: 1 From 09a9afea199991d9cf9ad17538999fcf42e5da36 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 15 Oct 2023 18:50:26 -0400 Subject: [PATCH 024/106] [minor] update operator path --- docs/source/api_operators.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/api_operators.rst b/docs/source/api_operators.rst index f8c607d3..7933fd01 100644 --- a/docs/source/api_operators.rst +++ b/docs/source/api_operators.rst @@ -1,7 +1,7 @@ torchquantum.operators ====================== -.. currentmodule:: torchquantum.operators +.. currentmodule:: torchquantum.operator Classes --------- From a5325753e75672acf697c0a03664c2d4f29bc1cc Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 15 Oct 2023 19:01:29 -0400 Subject: [PATCH 025/106] running example to test functionality --- .github/workflows/example_tests.yaml | 32 +++++++++++++++++++++++++ .github/workflows/functional_tests.yaml | 3 +++ 2 files changed, 35 insertions(+) create mode 100644 .github/workflows/example_tests.yaml diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml new file mode 100644 index 00000000..d8db7db3 --- /dev/null +++ b/.github/workflows/example_tests.yaml @@ -0,0 +1,32 @@ +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python + +name: Python package + +on: + push: + pull_request: + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Test Examples + run: | + python3 examples/qubit_rotation/qubit_rotation.py diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index af549120..ed42b3e5 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -36,3 +36,6 @@ jobs: - name: Test with pytest run: | pytest -m "not skip" + - name: Test Examples + run: | + python3 examples/qubit_rotation/qubit_rotation.py From 1d7fece886aac260f5db4c3db224845f166cfb65 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 15 Oct 2023 19:09:43 -0400 Subject: [PATCH 026/106] fixing attempt --- .github/workflows/functional_tests.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index ed42b3e5..9b26ef72 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -36,6 +36,9 @@ jobs: - name: Test with pytest run: | pytest -m "not skip" + - name: Install TorchQuantum + run: | + pip install --editable . - name: Test Examples run: | python3 examples/qubit_rotation/qubit_rotation.py From c6019f8433baa30cf261962ce6f4e965344125ed Mon Sep 17 00:00:00 2001 From: Vivek Yanamadula Date: Tue, 17 Oct 2023 01:36:55 -0400 Subject: [PATCH 027/106] Fixes bug with importing transpiled circuits which are mapped naively (resulting in a set initial_layout but a null final_layout) --- torchquantum/plugin/qiskit/qiskit_plugin.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/torchquantum/plugin/qiskit/qiskit_plugin.py b/torchquantum/plugin/qiskit/qiskit_plugin.py index 9dca0649..bca3a7d2 100644 --- a/torchquantum/plugin/qiskit/qiskit_plugin.py +++ b/torchquantum/plugin/qiskit/qiskit_plugin.py @@ -682,7 +682,10 @@ def qiskit2tq_Operator(circ: QuantumCircuit): try: p2v_orig = circ._layout.final_layout.get_physical_bits().copy() except: - p2v_orig = circ._layout.get_physical_bits().copy() + try: + p2v_orig = circ._layout.get_physical_bits().copy() + except: + p2v_orig = circ._layout.initial_layout.get_physical_bits().copy() p2v = {} for p, v in p2v_orig.items(): if v.register.name == "q": From 9f38792b56d065bec3fd241a1841b68ceb23beb8 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 20 Oct 2023 21:46:14 -0400 Subject: [PATCH 028/106] [minor] cleaned unused imports and specified imported variables --- torchquantum/layer/nlocal/__init__.py | 12 ++++++------ torchquantum/layer/nlocal/efficient_su2.py | 8 +------- torchquantum/layer/nlocal/excitation_preserving.py | 8 +------- torchquantum/layer/nlocal/nlocal.py | 2 -- torchquantum/layer/nlocal/pauli_two.py | 8 ++------ torchquantum/layer/nlocal/real_amplitudes.py | 8 +------- torchquantum/layer/nlocal/two_local.py | 5 +---- 7 files changed, 12 insertions(+), 39 deletions(-) diff --git a/torchquantum/layer/nlocal/__init__.py b/torchquantum/layer/nlocal/__init__.py index 2b24001e..a6a30bfc 100644 --- a/torchquantum/layer/nlocal/__init__.py +++ b/torchquantum/layer/nlocal/__init__.py @@ -1,6 +1,6 @@ -from .nlocal import * -from .two_local import * -from .excitation_preserving import * -from .real_amplitudes import * -from .efficient_su2 import * -from .pauli_two import * +from .nlocal import NLocal +from .two_local import TwoLocal +from .excitation_preserving import ExcitationPreserving +from .real_amplitudes import RealAmplitudes +from .efficient_su2 import EfficientSU2 +from .pauli_two import PauliTwoDesign diff --git a/torchquantum/layer/nlocal/efficient_su2.py b/torchquantum/layer/nlocal/efficient_su2.py index c66eea97..27a2e0d7 100644 --- a/torchquantum/layer/nlocal/efficient_su2.py +++ b/torchquantum/layer/nlocal/efficient_su2.py @@ -22,20 +22,14 @@ SOFTWARE. """ -import torch import torchquantum as tq -from torchquantum.layer.layers import ( - LayerTemplate0, - Op1QAllLayer, - Op2QAllLayer, - RandomOp1All, -) from .two_local import TwoLocal __all__ = [ "EfficientSU2", ] + class EfficientSU2(TwoLocal): """Layer Template for a EfficientSU2 circuit diff --git a/torchquantum/layer/nlocal/excitation_preserving.py b/torchquantum/layer/nlocal/excitation_preserving.py index 5185a315..4fa576ca 100644 --- a/torchquantum/layer/nlocal/excitation_preserving.py +++ b/torchquantum/layer/nlocal/excitation_preserving.py @@ -22,20 +22,14 @@ SOFTWARE. """ -import torch import torchquantum as tq -from torchquantum.layer.layers import ( - LayerTemplate0, - Op1QAllLayer, - Op2QAllLayer, - RandomOp1All, -) from .two_local import TwoLocal __all__ = [ "ExcitationPreserving", ] + class ExcitationPreserving(TwoLocal): """Layer Template for a ExcitationPreserving circuit diff --git a/torchquantum/layer/nlocal/nlocal.py b/torchquantum/layer/nlocal/nlocal.py index 3a58f28b..16e3d378 100644 --- a/torchquantum/layer/nlocal/nlocal.py +++ b/torchquantum/layer/nlocal/nlocal.py @@ -22,13 +22,11 @@ SOFTWARE. """ -import torch import torchquantum as tq from torchquantum.layer.layers import ( LayerTemplate0, Op1QAllLayer, Op2QAllLayer, - RandomOp1All, ) __all__ = [ diff --git a/torchquantum/layer/nlocal/pauli_two.py b/torchquantum/layer/nlocal/pauli_two.py index 03a24073..4b55b052 100644 --- a/torchquantum/layer/nlocal/pauli_two.py +++ b/torchquantum/layer/nlocal/pauli_two.py @@ -24,18 +24,14 @@ import torch import torchquantum as tq -from torchquantum.layer.layers import ( - LayerTemplate0, - Op1QAllLayer, - Op2QAllLayer, - RandomOp1All, -) +from torchquantum.layer.layers import RandomOp1All from .two_local import TwoLocal __all__ = [ "PauliTwoDesign", ] + class PauliTwoDesign(TwoLocal): """Layer Template for a PauliTwoDesign circuit diff --git a/torchquantum/layer/nlocal/real_amplitudes.py b/torchquantum/layer/nlocal/real_amplitudes.py index b676c076..bcece049 100644 --- a/torchquantum/layer/nlocal/real_amplitudes.py +++ b/torchquantum/layer/nlocal/real_amplitudes.py @@ -22,20 +22,14 @@ SOFTWARE. """ -import torch import torchquantum as tq -from torchquantum.layer.layers import ( - LayerTemplate0, - Op1QAllLayer, - Op2QAllLayer, - RandomOp1All, -) from .two_local import TwoLocal __all__ = [ "RealAmplitudes", ] + class RealAmplitudes(TwoLocal): """Layer Template for a RealAmplitudes circuit diff --git a/torchquantum/layer/nlocal/two_local.py b/torchquantum/layer/nlocal/two_local.py index ab48d670..452191e6 100644 --- a/torchquantum/layer/nlocal/two_local.py +++ b/torchquantum/layer/nlocal/two_local.py @@ -22,14 +22,10 @@ SOFTWARE. """ - -import torch import torchquantum as tq from torchquantum.layer.layers import ( - LayerTemplate0, Op1QAllLayer, Op2QAllLayer, - RandomOp1All, ) from .nlocal import NLocal @@ -37,6 +33,7 @@ "TwoLocal", ] + class TwoLocal(NLocal): """Layer Template for a TwoLocal Class From c11b124872d57ba890fc5754ac2f5aac0ae1e1b3 Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Fri, 20 Oct 2023 21:54:48 -0400 Subject: [PATCH 029/106] [minor] add qubit rotation tutorial --- examples/index.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/index.rst b/examples/index.rst index e36da434..c9bd9c24 100644 --- a/examples/index.rst +++ b/examples/index.rst @@ -8,4 +8,6 @@ TorchQuantum Examples param_shift_onchip_training/param_shift_onchip_training.ipynb quantum_kernel_method/quantum_kernel_method.ipynb quanvolution/quanvolution.ipynb - superdense_coding/superdense_coding_torchquantum.ipynb \ No newline at end of file + superdense_coding/superdense_coding_torchquantum.ipynb + qubit_rotation/TQ_Qubit_Rotation_Tutorial.ipynb + From e609afd31cd206f2970320f643ab005097d05fbe Mon Sep 17 00:00:00 2001 From: Hanrui Wang Date: Sat, 28 Oct 2023 15:36:08 -0400 Subject: [PATCH 030/106] Update README.md --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 35bcc9ef..d905eb03 100644 --- a/README.md +++ b/README.md @@ -7,12 +7,13 @@

- - MIT License - Documentation + + MIT License + + Chat @ Slack From 7af4f4937e3bf4b112985338c1bf0510423dfd13 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 3 Nov 2023 18:38:42 -0400 Subject: [PATCH 031/106] adding entangle layers --- torchquantum/layer/layers.py | 121 ++++++++++++++++++++++++++++++++++- 1 file changed, 120 insertions(+), 1 deletion(-) diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index 9f129acc..63c2b903 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -52,6 +52,10 @@ "SWAPSWAPLayer", "RXYZCXLayer0", "QFTLayer", + "EntangleLinear", + "EntanglePairwise", + "EntangleFull", + "EntangleCircular", ] @@ -764,7 +768,7 @@ def forward(self, q_device): self.ops_all[k](q_device, wires=wires) -class Op2QDenseLayer(tq.QuantumModule): +class EntangleFull(tq.QuantumModule): """ Quantum layer applying the same two-qubit operation in a dense pattern. @@ -810,6 +814,8 @@ def forward(self, q_device): self.ops_all[k](q_device, wires=wires) k += 1 +# Adding an alias to the previous name +Op2QDenseLayer = EntangleFull class LayerTemplate0(tq.QuantumModule): """ @@ -1616,6 +1622,119 @@ def build_inverse_circuit(self): def forward(self, q_device: tq.QuantumDevice): self.gates_all(q_device) +class EntangleLinear(Op2QAllLayer): + """ + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + """ + """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] + """ + + def __init__( + self, + op, + n_wires: int, + has_params=False, + trainable=False, + wire_reverse=False, + ): + super().__init__(op=op, n_wires=n_wires, has_params=has_params, trainable=trainable, wire_reverse=wire_reverse, jump=1, circular=False) + + +class EntangleCircular(Op2QAllLayer): + """ + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires in a circular manner. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device with a wrap-around + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ + """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] + """ + + def __init__( + self, + op, + n_wires: int, + has_params=False, + trainable=False, + wire_reverse=False, + ): + super().__init__(op=op, n_wires=n_wires, has_params=has_params, trainable=trainable, wire_reverse=wire_reverse, jump=1, circular=True) + + + +class EntanglePairwise(tq.QuantumModule): + """ + Quantum layer applying the same two-qubit operation in a pair-wise pattern + + This class represents a quantum layer that applies the same two-qubit operation in a pairwise pattern. The pairwise pattern first entangles all qubits i with i+1 for even i then all qubits i with i+1 for odd i. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ + """pattern: + [0, 1], [2, 3], [4, 5] + [1, 2], [3, 4] + """ + + def __init__( + self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False + ): + super().__init__() + self.n_wires = n_wires + self.op = op + self.ops_all = tq.QuantumModuleList() + + # reverse the wires, for example from [1, 2] to [2, 1] + self.wire_reverse = wire_reverse + + for k in range(self.n_wires-1): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + def forward(self, q_device): + k = 0 + + # entangle qubit i with i+1 for all even values of i + for i in range(self.n_wires - 1): + if i % 2 == 0: + wires = [i, i+1] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + k += 1 + + # entangle qubit i with i+1 for all odd values of i + for i in range(1, self.n_wires - 1): + if i % 2 == 1: + wires = [i, i+1] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + k += 1 + + layer_name_dict = { "u3cu3_0": U3CU3Layer0, From 3b0bdaf962dfc3126f56b47e28d48ce0b20c6c22 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 3 Nov 2023 18:39:35 -0400 Subject: [PATCH 032/106] running style updates on layers --- torchquantum/layer/layers.py | 818 ++++++++++++++++++----------------- 1 file changed, 431 insertions(+), 387 deletions(-) diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index 63c2b903..a859730a 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -62,10 +62,11 @@ class QuantumModuleFromOps(tq.QuantumModule): """Initializes a QuantumModuleFromOps instance. - Args: - ops (List[tq.Operation]): List of quantum operations. + Args: + ops (List[tq.Operation]): List of quantum operations. + + """ - """ def __init__(self, ops): super().__init__() self.ops = tq.QuantumModuleList(ops) @@ -74,13 +75,13 @@ def __init__(self, ops): def forward(self, q_device: tq.QuantumDevice): """Performs the forward pass of the quantum module. - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. - Returns: - None + Returns: + None - """ + """ self.q_device = q_device for op in self.ops: op(q_device) @@ -115,18 +116,19 @@ def forward(self, q_device: tq.QuantumDevice): class ClassicalInOpAll(tq.QuantumModule): """ - Quantum module that applies the same quantum operation to all wires of a quantum device, - where the parameters of the operation are obtained from a classical input. + Quantum module that applies the same quantum operation to all wires of a quantum device, + where the parameters of the operation are obtained from a classical input. + + Args: + n_gate (int): Number of gates. + op (tq.Operator): Quantum operation to be applied. - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. + Attributes: + n_gate (int): Number of gates. + gate_all (nn.ModuleList): List of quantum operations. - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. + """ - """ def __init__(self, n_gate: int, op: tq.Operator): super().__init__() self.n_gate = n_gate @@ -137,19 +139,19 @@ def __init__(self, n_gate: int, op: tq.Operator): @tq.static_support def forward(self, q_device: tq.QuantumDevice, x): """ - Performs the forward pass of the classical input quantum operation module. + Performs the forward pass of the classical input quantum operation module. - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - x (torch.Tensor): Classical input of shape (batch_size, n_gate). + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. + x (torch.Tensor): Classical input of shape (batch_size, n_gate). - Returns: - None + Returns: + None - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. + Raises: + AssertionError: If the number of gates is different from the number of wires in the device. - """ + """ # rx on all wires, assert the number of gate is the same as the number # of wires in the device. assert self.n_gate == q_device.n_wires, ( @@ -163,17 +165,18 @@ def forward(self, q_device: tq.QuantumDevice, x): class FixedOpAll(tq.QuantumModule): """ - Quantum module that applies the same fixed quantum operation to all wires of a quantum device. + Quantum module that applies the same fixed quantum operation to all wires of a quantum device. - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. + Args: + n_gate (int): Number of gates. + op (tq.Operator): Quantum operation to be applied. - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. + Attributes: + n_gate (int): Number of gates. + gate_all (nn.ModuleList): List of quantum operations. + + """ - """ def __init__(self, n_gate: int, op: tq.Operator): super().__init__() self.n_gate = n_gate @@ -184,18 +187,18 @@ def __init__(self, n_gate: int, op: tq.Operator): @tq.static_support def forward(self, q_device: tq.QuantumDevice): """ - Performs the forward pass of the fixed quantum operation module. + Performs the forward pass of the fixed quantum operation module. - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. - Returns: - None + Returns: + None - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. + Raises: + AssertionError: If the number of gates is different from the number of wires in the device. - """ + """ # rx on all wires, assert the number of gate is the same as the number # of wires in the device. assert self.n_gate == q_device.n_wires, ( @@ -209,17 +212,18 @@ def forward(self, q_device: tq.QuantumDevice): class TwoQAll(tq.QuantumModule): """ - Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. + Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. - Args: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation to be applied. + Args: + n_gate (int): Number of adjacent pairs of wires. + op (tq.Operator): Two-qubit quantum operation to be applied. - Attributes: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation. + Attributes: + n_gate (int): Number of adjacent pairs of wires. + op (tq.Operator): Two-qubit quantum operation. + + """ - """ def __init__(self, n_gate: int, op: tq.Operator): super().__init__() self.n_gate = n_gate @@ -274,28 +278,29 @@ def forward(self, q_device: tq.QuantumDevice, x): class RandomLayer(tq.QuantumModule): """ - Quantum module that represents a random layer of quantum operations applied to specified wires. + Quantum module that represents a random layer of quantum operations applied to specified wires. - Args: - wires (int or Iterable[int]): Indices of the wires the operations are applied to. - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - op_ratios (list or float): Ratios determining the relative frequencies of different operation types. - op_types (tuple or tq.Operator): Types of random operations to be included in the layer. - seed (int): Seed for random number generation. - qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. - - Attributes: - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - wires (list): Indices of the wires the operations are applied to. - n_wires (int): Number of wires. - op_types (list): Types of random operations included in the layer. - op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. - seed (int): Seed for random number generation. - op_list (tq.QuantumModuleList): List of random operations in the layer. + Args: + wires (int or Iterable[int]): Indices of the wires the operations are applied to. + n_ops (int): Number of random operations in the layer. + n_params (int): Number of parameters for each random operation. + op_ratios (list or float): Ratios determining the relative frequencies of different operation types. + op_types (tuple or tq.Operator): Types of random operations to be included in the layer. + seed (int): Seed for random number generation. + qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. + + Attributes: + n_ops (int): Number of random operations in the layer. + n_params (int): Number of parameters for each random operation. + wires (list): Indices of the wires the operations are applied to. + n_wires (int): Number of wires. + op_types (list): Types of random operations included in the layer. + op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. + seed (int): Seed for random number generation. + op_list (tq.QuantumModuleList): List of random operations in the layer. + + """ - """ def __init__( self, wires, @@ -346,15 +351,15 @@ def __init__( def rebuild_random_layer_from_op_list(self, n_ops_in, wires_in, op_list_in): """ - Rebuilds a random layer from the given operation list. - This method is used for loading a random layer from a checkpoint. + Rebuilds a random layer from the given operation list. + This method is used for loading a random layer from a checkpoint. - Args: - n_ops_in (int): Number of operations in the layer. - wires_in (list): Indices of the wires the operations are applied to. - op_list_in (list): List of operations in the layer. + Args: + n_ops_in (int): Number of operations in the layer. + wires_in (list): Indices of the wires the operations are applied to. + op_list_in (list): List of operations in the layer. - """ + """ self.n_ops = n_ops_in self.wires = wires_in @@ -425,20 +430,21 @@ def forward(self, q_device: tq.QuantumDevice): class RandomLayerAllTypes(RandomLayer): """ - Random layer with a wide range of quantum gate types. + Random layer with a wide range of quantum gate types. + + This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. - This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. + Args: + wires (int or list): Indices of the wires the operations are applied to. + n_ops (int): Number of operations in the layer. + n_params (int): Number of parameters for each operation. + op_ratios (list): Ratios for selecting different types of operations. + op_types (tuple): Types of operations to include in the layer. + seed (int): Seed for the random number generator. + qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. - Args: - wires (int or list): Indices of the wires the operations are applied to. - n_ops (int): Number of operations in the layer. - n_params (int): Number of parameters for each operation. - op_ratios (list): Ratios for selecting different types of operations. - op_types (tuple): Types of operations to include in the layer. - seed (int): Seed for the random number generator. - qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. + """ - """ def __init__( self, wires, @@ -493,14 +499,15 @@ def __init__( class SimpleQLayer(tq.QuantumModule): """ - Simple quantum layer consisting of three parameterized gates applied to specific wires. + Simple quantum layer consisting of three parameterized gates applied to specific wires. + + This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. - This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -520,14 +527,15 @@ def forward(self, q_dev): class CXLayer(tq.QuantumModule): """ - Quantum layer with a controlled-X (CX) gate applied to two specified wires. + Quantum layer with a controlled-X (CX) gate applied to two specified wires. - This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. + This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. + + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -540,14 +548,15 @@ def forward(self, q_dev): class CXCXCXLayer(tq.QuantumModule): """ - Quantum layer with a sequence of CX gates applied to three specified wires. + Quantum layer with a sequence of CX gates applied to three specified wires. - This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. + This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. + + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -562,14 +571,15 @@ def forward(self, q_dev): class SWAPSWAPLayer(tq.QuantumModule): """ - Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. + Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. - This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. + This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. + + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -583,17 +593,18 @@ def forward(self, q_dev): class Op1QAllLayer(tq.QuantumModule): """ - Quantum layer applying the same single-qubit operation to all wires. + Quantum layer applying the same single-qubit operation to all wires. - This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. + This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. - Args: - op (tq.Operator): Single-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + Args: + op (tq.Operator): Single-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + + """ - """ def __init__(self, op, n_wires: int, has_params=False, trainable=False): super().__init__() self.n_wires = n_wires @@ -610,21 +621,22 @@ def forward(self, q_device): class Op2QAllLayer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the - specified jump. + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the + specified jump. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. """ + """pattern: circular = False jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] @@ -679,20 +691,21 @@ def forward(self, q_device): class Op2QFit32Layer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ - """ def __init__( self, op, @@ -732,18 +745,19 @@ def forward(self, q_device): class Op2QButterflyLayer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation in a butterfly pattern. + Quantum layer applying the same two-qubit operation in a butterfly pattern. - This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. + This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ - """ """pattern: [0, 5], [1, 4], [2, 3]""" def __init__( @@ -770,18 +784,19 @@ def forward(self, q_device): class EntangleFull(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation in a dense pattern. + Quantum layer applying the same two-qubit operation in a dense pattern. - This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. + This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ - """ """pattern: [0, 1], [0, 2], [0, 3], [0, 4], [0, 5] [1, 2], [1, 3], [1, 4], [1, 5] @@ -814,28 +829,31 @@ def forward(self, q_device): self.ops_all[k](q_device, wires=wires) k += 1 + # Adding an alias to the previous name -Op2QDenseLayer = EntangleFull +Op2QDenseLayer = EntangleFull + class LayerTemplate0(tq.QuantumModule): """ - A template for a custom quantum layer. + A template for a custom quantum layer. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. (Optional) + n_layers_per_block (int): The number of layers per block. (Optional) + layers_all (tq.QuantumModuleList): The list of layers in the template. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. (Optional) - n_layers_per_block (int): The number of layers per block. (Optional) - layers_all (tq.QuantumModuleList): The list of layers in the template. + Methods: + build_layers: Abstract method to build the layers of the template. + forward: Applies the quantum layer to the given quantum device. - Methods: - build_layers: Abstract method to build the layers of the template. - forward: Applies the quantum layer to the given quantum device. + """ - """ def __init__(self, arch: dict = None): super().__init__() self.n_wires = arch["n_wires"] @@ -858,25 +876,24 @@ def forward(self, q_device: tq.QuantumDevice): class U3CU3Layer0(LayerTemplate0): """ - Layer template with U3 and CU3 blocks. + Layer template with U3 and CU3 blocks. - This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. + This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Methods: - build_layers: Builds the U3 and CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - """ + Methods: + build_layers: Builds the U3 and CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -901,25 +918,24 @@ def build_layers(self): class CU3Layer0(LayerTemplate0): """ - Layer template with CU3 blocks. + Layer template with CU3 blocks. - This layer template consists of CU3 blocks repeated for the specified number of blocks. + This layer template consists of CU3 blocks repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Methods: - build_layers: Builds the CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - """ + Methods: + build_layers: Builds the CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -939,25 +955,24 @@ def build_layers(self): class CXRZSXLayer0(LayerTemplate0): """ - Layer template with CXRZSX blocks. + Layer template with CXRZSX blocks. - This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. + This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Methods: - build_layers: Builds the CXRZSX layers for the template. - forward: Applies the quantum layer to the given quantum device. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - """ + Methods: + build_layers: Builds the CXRZSX layers for the template. + forward: Applies the quantum layer to the given quantum device. + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -991,24 +1006,25 @@ def build_layers(self): class SethLayer0(LayerTemplate0): """ - Layer template with Seth blocks. + Layer template with Seth blocks. - This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. + This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1032,24 +1048,25 @@ def build_layers(self): class SethLayer1(LayerTemplate0): """ - Layer template with extended Seth blocks. + Layer template with extended Seth blocks. - This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. + This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Methods: + build_layers: Builds the extended Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. - Methods: - build_layers: Builds the extended Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1083,24 +1100,25 @@ def build_layers(self): class SethLayer2(LayerTemplate0): """ - Layer template with Seth blocks using Op2QFit32Layer. + Layer template with Seth blocks using Op2QFit32Layer. - This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. + This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Seth layers with Op2QFit32Layer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Seth layers with Op2QFit32Layer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1119,24 +1137,25 @@ def build_layers(self): class RZZLayer0(LayerTemplate0): """ - Layer template with RZZ blocks. + Layer template with RZZ blocks. - This layer template consists of RZZ blocks using the Op2QAllLayer. + This layer template consists of RZZ blocks using the Op2QAllLayer. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RZZ layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the RZZ layers with Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1155,24 +1174,25 @@ def build_layers(self): class BarrenLayer0(LayerTemplate0): """ - Layer template with Barren blocks. + Layer template with Barren blocks. - This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. + This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() layers_all.append( @@ -1203,24 +1223,25 @@ def build_layers(self): class FarhiLayer0(LayerTemplate0): """ - Layer template with Farhi blocks. + Layer template with Farhi blocks. + + This layer template consists of Farhi blocks using the Op2QAllLayer. - This layer template consists of Farhi blocks using the Op2QAllLayer. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Methods: + build_layers: Builds the Farhi layers with Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. - Methods: - build_layers: Builds the Farhi layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1249,24 +1270,25 @@ def build_layers(self): class MaxwellLayer0(LayerTemplate0): """ - Layer template with Maxwell blocks. + Layer template with Maxwell blocks. + + This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. - This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Methods: + build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. - Methods: - build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1321,24 +1343,25 @@ def build_layers(self): class RYRYCXLayer0(LayerTemplate0): """ - Layer template with RYRYCX blocks. + Layer template with RYRYCX blocks. - This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. + This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1353,23 +1376,23 @@ def build_layers(self): class RYRYRYCXCXCXLayer0(LayerTemplate0): """ - Layer template with RYRYRYCXCXCX blocks. + Layer template with RYRYRYCXCXCX blocks. - This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. + This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. - """ + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -1385,24 +1408,25 @@ def build_layers(self): class RYRYRYLayer0(LayerTemplate0): """ - Layer template with RYRYRYCXCXCX blocks. + Layer template with RYRYRYCXCXCX blocks. - This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. + This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. - """ + """ + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1416,24 +1440,25 @@ def build_layers(self): class RYRYRYSWAPSWAPLayer0(LayerTemplate0): """ - Layer template with RYRYRYSWAPSWAP blocks. + Layer template with RYRYRYSWAPSWAP blocks. - This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. + This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. + Methods: + build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. - """ + """ + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1448,23 +1473,23 @@ def build_layers(self): class SWAPSWAPLayer0(LayerTemplate0): """ - Layer template with SWAPSWAP blocks. + Layer template with SWAPSWAP blocks. - This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. + This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. + Methods: + build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. - """ + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -1475,23 +1500,24 @@ def build_layers(self): class RXYZCXLayer0(LayerTemplate0): """ - Layer template with RXYZCX blocks. + Layer template with RXYZCX blocks. - This layer template consists of RXYZCX blocks using the RXYZCXLayer module. + This layer template consists of RXYZCX blocks using the RXYZCXLayer module. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. + Methods: + build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1622,11 +1648,12 @@ def build_inverse_circuit(self): def forward(self, q_device: tq.QuantumDevice): self.gates_all(q_device) + class EntangleLinear(Op2QAllLayer): """ Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. + in the quantum device. Args: op (tq.Operator): Two-qubit operation to be applied. @@ -1635,6 +1662,7 @@ class EntangleLinear(Op2QAllLayer): trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. """ + """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] """ @@ -1646,14 +1674,22 @@ def __init__( trainable=False, wire_reverse=False, ): - super().__init__(op=op, n_wires=n_wires, has_params=has_params, trainable=trainable, wire_reverse=wire_reverse, jump=1, circular=False) + super().__init__( + op=op, + n_wires=n_wires, + has_params=has_params, + trainable=trainable, + wire_reverse=wire_reverse, + jump=1, + circular=False, + ) class EntangleCircular(Op2QAllLayer): """ Quantum layer applying the same two-qubit operation to all pairs of adjacent wires in a circular manner. This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device with a wrap-around + in the quantum device with a wrap-around Args: op (tq.Operator): Two-qubit operation to be applied. @@ -1665,6 +1701,7 @@ class EntangleCircular(Op2QAllLayer): circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. """ + """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] """ @@ -1676,13 +1713,20 @@ def __init__( trainable=False, wire_reverse=False, ): - super().__init__(op=op, n_wires=n_wires, has_params=has_params, trainable=trainable, wire_reverse=wire_reverse, jump=1, circular=True) - + super().__init__( + op=op, + n_wires=n_wires, + has_params=has_params, + trainable=trainable, + wire_reverse=wire_reverse, + jump=1, + circular=True, + ) class EntanglePairwise(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation in a pair-wise pattern + Quantum layer applying the same two-qubit operation in a pair-wise pattern This class represents a quantum layer that applies the same two-qubit operation in a pairwise pattern. The pairwise pattern first entangles all qubits i with i+1 for even i then all qubits i with i+1 for odd i. @@ -1694,6 +1738,7 @@ class EntanglePairwise(tq.QuantumModule): wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. """ + """pattern: [0, 1], [2, 3], [4, 5] [1, 2], [3, 4] @@ -1710,7 +1755,7 @@ def __init__( # reverse the wires, for example from [1, 2] to [2, 1] self.wire_reverse = wire_reverse - for k in range(self.n_wires-1): + for k in range(self.n_wires - 1): self.ops_all.append(op(has_params=has_params, trainable=trainable)) def forward(self, q_device): @@ -1719,7 +1764,7 @@ def forward(self, q_device): # entangle qubit i with i+1 for all even values of i for i in range(self.n_wires - 1): if i % 2 == 0: - wires = [i, i+1] + wires = [i, i + 1] if self.wire_reverse: wires.reverse() self.ops_all[k](q_device, wires=wires) @@ -1728,14 +1773,13 @@ def forward(self, q_device): # entangle qubit i with i+1 for all odd values of i for i in range(1, self.n_wires - 1): if i % 2 == 1: - wires = [i, i+1] + wires = [i, i + 1] if self.wire_reverse: wires.reverse() self.ops_all[k](q_device, wires=wires) k += 1 - layer_name_dict = { "u3cu3_0": U3CU3Layer0, "cu3_0": CU3Layer0, From c4252010c073cb54859b7f1099eca6ca18f78fcd Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 3 Nov 2023 19:05:57 -0400 Subject: [PATCH 033/106] added more general entanglement class --- torchquantum/layer/layers.py | 54 ++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index a859730a..24cbde8f 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -56,6 +56,7 @@ "EntanglePairwise", "EntangleFull", "EntangleCircular", + "EntanglementLayer", ] @@ -1780,6 +1781,59 @@ def forward(self, q_device): k += 1 +class EntanglementLayer(tq.QuantumModule): + """ + Quantum layer applying a specified two-qubit entanglement type to all qubits. The entanglement types include full, linear, pairwise, and circular. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + entanglement_type (str): Type of entanglement from ["full", "linear", "pairwise", "circular"] + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ + + def __init__( + self, + op, + n_wires: int, + entanglement_type: str, + has_params=False, + trainable=False, + wire_reverse=False, + ): + super().__init__() + + entanglement_to_class = { + "full": EntangleFull, + "linear": EntangleLinear, + "pairwise": EntanglePairwise, + "circular": EntangleCircular, + } + + self.entanglement_class = entanglement_to_class.get(entanglement_type, None) + + assert ( + self.entanglement_class is not None + ), f"invalid entanglement type {entanglement_type}" + + self.entanglement_class.__init__( + op=op, + n_wires=n_wires, + has_params=has_params, + trainable=trainable, + wire_reverse=wire_reverse, + ) + + @tq.static_support + def forward(self, q_device): + self.entanglement_class.forward(q_device) + + layer_name_dict = { "u3cu3_0": U3CU3Layer0, "cu3_0": CU3Layer0, From a95e84224b653d101ee05ed109f7ae6184796ba9 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 3 Nov 2023 20:00:12 -0400 Subject: [PATCH 034/106] [minor] updating isometry import --- torchquantum/plugin/qiskit/qiskit_unitary_gate.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/torchquantum/plugin/qiskit/qiskit_unitary_gate.py b/torchquantum/plugin/qiskit/qiskit_unitary_gate.py index d2b93577..6e520b96 100644 --- a/torchquantum/plugin/qiskit/qiskit_unitary_gate.py +++ b/torchquantum/plugin/qiskit/qiskit_unitary_gate.py @@ -23,7 +23,6 @@ from qiskit.circuit.exceptions import CircuitError from qiskit.circuit._utils import _compute_control_matrix from qiskit.circuit.library.standard_gates import U3Gate -from qiskit.extensions.quantum_initializer import isometry from qiskit.quantum_info.operators.predicates import matrix_equal from qiskit.quantum_info.operators.predicates import is_unitary_matrix from qiskit.quantum_info.synthesis.one_qubit_decompose import OneQubitEulerDecomposer @@ -117,7 +116,7 @@ def _define(self): else: q = QuantumRegister(self.num_qubits, "q") qc = QuantumCircuit(q, name=self.name) - qc.append(isometry.Isometry(self.to_matrix(), 0, 0), qargs=q[:]) + qc.append(qiskit.circuit.library.Isometry(self.to_matrix(), 0, 0), qargs=q[:]) self.definition = qc def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None): @@ -139,7 +138,7 @@ def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None): cmat = _compute_control_matrix( self.to_matrix(), num_ctrl_qubits, ctrl_state=None ) - iso = isometry.Isometry(cmat, 0, 0) + iso = qiskit.circuit.library.Isometry(cmat, 0, 0) cunitary = ControlledGate( "c-unitary", num_qubits=self.num_qubits + num_ctrl_qubits, From d1b6a90bd1d0753ba7236a8d86f70ec726e410db Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 3 Nov 2023 21:49:58 -0400 Subject: [PATCH 035/106] [minor] update to be compatible with documentation --- examples/superdense_coding/superdense_coding_torchquantum.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/superdense_coding/superdense_coding_torchquantum.ipynb b/examples/superdense_coding/superdense_coding_torchquantum.ipynb index 3f53e91c..e4128624 100644 --- a/examples/superdense_coding/superdense_coding_torchquantum.ipynb +++ b/examples/superdense_coding/superdense_coding_torchquantum.ipynb @@ -502,7 +502,7 @@ "id": "nFC9-bqHbG2I" }, "source": [ - "# References:\n", + "## References:\n", "\n", "[1] Bennett, C.H., Brassard, G., Crépeau, C., Jozsa, R., Peres, A. and Wootters, W.K., 1993. Teleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels. Physical review letters, 70(13), p.1895.\n", "\n", From 5a1d4d72125e42c0fce2d8808e7d1b2c56319644 Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Sat, 4 Nov 2023 11:49:18 -0400 Subject: [PATCH 036/106] [minor] entanglement_type -> entanglement --- torchquantum/layer/layers.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index 24cbde8f..a28785cd 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -1788,7 +1788,7 @@ class EntanglementLayer(tq.QuantumModule): Args: op (tq.Operator): Two-qubit operation to be applied. n_wires (int): Number of wires in the quantum device. - entanglement_type (str): Type of entanglement from ["full", "linear", "pairwise", "circular"] + entanglement (str): Type of entanglement from ["full", "linear", "pairwise", "circular"] has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. @@ -1801,7 +1801,7 @@ def __init__( self, op, n_wires: int, - entanglement_type: str, + entanglement: str, has_params=False, trainable=False, wire_reverse=False, @@ -1815,11 +1815,11 @@ def __init__( "circular": EntangleCircular, } - self.entanglement_class = entanglement_to_class.get(entanglement_type, None) + self.entanglement_class = entanglement_to_class.get(entanglement, None) assert ( self.entanglement_class is not None - ), f"invalid entanglement type {entanglement_type}" + ), f"invalid entanglement type {entanglement}" self.entanglement_class.__init__( op=op, From f53bb6c87f2b98138c62d297fcbb948e371f2892 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 11 Nov 2023 17:50:33 -0500 Subject: [PATCH 037/106] preliminary twolocal test for similar structure --- test/layers/test_layers.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 test/layers/test_layers.py diff --git a/test/layers/test_layers.py b/test/layers/test_layers.py new file mode 100644 index 00000000..760dc46e --- /dev/null +++ b/test/layers/test_layers.py @@ -0,0 +1,37 @@ +import torchquantum as tq +from qiskit.circuit.library import TwoLocal + +for entanglement_type in ("linear", "circular", "full"): + for n_wires in (3, 5, 10): + for reps in range(5): + + # create the TQ circuit + two2 = tq.layer.TwoLocal([tq.RY, tq.RZ], [tq.CZ], arch={"n_wires": n_wires}, entanglement_layer=entanglement_type, reps=reps) + qdev = tq.QuantumDevice(n_wires, record_op=True) + two2(qdev) + + # create the qiskit circuit + two = TwoLocal(n_wires, ['ry','rz'], 'cz', entanglement_type, reps=reps, insert_barriers=False) + operations = [] + for bit in two.decompose(): + wires = [] + for qu in bit.qubits: + wires.append(qu.index) + operations.append({ + "name": bit.operation.name, + "wires": tuple(wires), + }) + + # create operations list + qiskit_ops = operations + tq_ops = ([{"name": op["name"], "wires": (op["wires"],) if isinstance(op["wires"], int) else tuple(op["wires"])} for op in qdev.op_history]) + + # create tuples (NOTE: WILL LOSE ORDER SO NOT ENTIRELY CORRECT) + tq_ops_tuple = {tuple(op) for op in tq_ops} + qiskit_ops_tuple = {tuple(op) for op in qiskit_ops} + + # assert if they are the same + test_info = f"{entanglement_type} with {n_wires} wires and {reps} reps" + assert len(tq_ops) == len(qiskit_ops), f"operations are varying lengths for {test_info}" + assert tq_ops_tuple == qiskit_ops_tuple, f"operations do not match for {test_info}" + From b49125936868d8441257717907b92f0848a790da Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 11 Nov 2023 18:12:13 -0500 Subject: [PATCH 038/106] [minor] resolving missing import --- torchquantum/layer/nlocal/two_local.py | 1 + 1 file changed, 1 insertion(+) diff --git a/torchquantum/layer/nlocal/two_local.py b/torchquantum/layer/nlocal/two_local.py index 452191e6..23c976c9 100644 --- a/torchquantum/layer/nlocal/two_local.py +++ b/torchquantum/layer/nlocal/two_local.py @@ -26,6 +26,7 @@ from torchquantum.layer.layers import ( Op1QAllLayer, Op2QAllLayer, + Op2QDenseLayer, ) from .nlocal import NLocal From ff10729176e8db9a9b2336bfd327e42a5b1cba0f Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 11 Nov 2023 20:36:28 -0500 Subject: [PATCH 039/106] adding tests for other nlocal circuits --- test/layers/test_nlocal.py | 93 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 test/layers/test_nlocal.py diff --git a/test/layers/test_nlocal.py b/test/layers/test_nlocal.py new file mode 100644 index 00000000..57f019f4 --- /dev/null +++ b/test/layers/test_nlocal.py @@ -0,0 +1,93 @@ +import torchquantum as tq +from qiskit.circuit.library import TwoLocal, EfficientSU2, ExcitationPreserving, PauliTwoDesign, RealAmplitudes + +def compare_tq_to_qiskit(tq_circuit, qiskit_circuit, instance_info = ""): + """ + helper function to compare if tq and qiskit have the same gates configuration + """ + + qiskit_ops = [] + for bit in qiskit_circuit.decompose(): + wires = [] + for qu in bit.qubits: + wires.append(qu.index) + qiskit_ops.append( + { + "name": bit.operation.name, + "wires": tuple(wires), + } + ) + + # create operations list + tq_ops = [ + { + "name": op["name"], + "wires": (op["wires"],) + if isinstance(op["wires"], int) + else tuple(op["wires"]), + } + for op in tq_circuit.op_history + ] + + # create tuples (NOTE: WILL LOSE ORDER SO NOT ENTIRELY CORRECT) + tq_ops_tuple = {tuple(op) for op in tq_ops} + qiskit_ops_tuple = {tuple(op) for op in qiskit_ops} + + # assert if they are the same + assert len(tq_ops) == len( + qiskit_ops + ), f"operations are varying lengths for {instance_info}" + assert ( + tq_ops_tuple == qiskit_ops_tuple + ), f"operations do not match for {instance_info}" + +## TEST TWOLOCAL + +# iterate through different parameters to test +for entanglement_type in ("linear", "circular", "full"): + for n_wires in (3, 5, 10): + for reps in range(1, 5): + # create the TQ circuit + tq_two = tq.layer.TwoLocal( + [tq.RY, tq.RZ], + [tq.CZ], + arch={"n_wires": n_wires}, + entanglement_layer=entanglement_type, + reps=reps, + ) + qdev = tq.QuantumDevice(n_wires, record_op=True) + tq_two(qdev) + + # create the qiskit circuit + qiskit_two = TwoLocal( + n_wires, + ["ry", "rz"], + "cz", + entanglement_type, + reps=reps, + insert_barriers=False, + ) + + # compare the circuits + test_info = f"{entanglement_type} with {n_wires} wires and {reps} reps" + compare_tq_to_qiskit(qdev, qiskit_two) + + +## TEST OTHER CIRCUITS + +tq_to_qiskit = { + "EfficientSU2": (tq.layer.EfficientSU2, EfficientSU2), + "ExcitationPreserving": (tq.layer.ExcitationPreserving, ExcitationPreserving), + "RealAmplitudes": (tq.layer.RealAmplitudes, RealAmplitudes), +} + +# run all the tests +for circuit_name in tq_to_qiskit: + tq_instance, qiskit_instance = tq_to_qiskit[circuit_name] + for n_wires in range(2, 5): + tq_circuit = tq_instance({"n_wires": n_wires}) + circuit = qiskit_instance(n_wires) + qdev = tq.QuantumDevice(n_wires, record_op=True) + tq_circuit(qdev) + compare_tq_to_qiskit(qdev, circuit, f"{circuit_name} with {n_wires} wires") + From 43109a965f90ccaf89e115a3fc8d037fd75f3978 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 17 Nov 2023 19:15:21 -0500 Subject: [PATCH 040/106] fixed aliasing issue and added tests --- test/layers/test_rotgate.py | 54 +++++++++++++++++++++++++++++++++++ torchquantum/layer/general.py | 14 ++++----- 2 files changed, 59 insertions(+), 9 deletions(-) create mode 100644 test/layers/test_rotgate.py diff --git a/test/layers/test_rotgate.py b/test/layers/test_rotgate.py new file mode 100644 index 00000000..beec6d72 --- /dev/null +++ b/test/layers/test_rotgate.py @@ -0,0 +1,54 @@ +import torchquantum as tq +import qiskit +from qiskit import Aer, execute + +from torchquantum.util import ( + switch_little_big_endian_matrix, + find_global_phase, +) + +from qiskit.circuit.library import GR, GRX, GRY +import numpy as np + +all_pairs = [ + # {"qiskit": GR, "tq": tq.layer.GlobalR, "params": 2}, + {"qiskit": GRX, "tq": tq.layer.GlobalRX, "params": 1}, + {"qiskit": GRY, "tq": tq.layer.GlobalRY, "params": 1}, +] + +ITERATIONS = 10 + +# test each pair +for pair in all_pairs: + # test 2-5 wires + for num_wires in range(2, 5): + # try multiple random parameters + for _ in range(ITERATIONS): + # generate random parameters + params = [ + np.random.uniform(-2 * np.pi, 2 * np.pi) for _ in range(pair["params"]) + ] + + # create the qiskit circuit + qiskit_circuit = pair["qiskit"](num_wires, *params) + + # get the unitary from qiskit + backend = Aer.get_backend("unitary_simulator") + result = execute(qiskit_circuit, backend).result() + unitary_qiskit = result.get_unitary(qiskit_circuit) + + # create tq circuit + qdev = tq.QuantumDevice(num_wires) + tq_circuit = pair["tq"](num_wires, *params) + tq_circuit(qdev) + + # get the unitary from tq + unitary_tq = tq_circuit.get_unitary(qdev) + unitary_tq = switch_little_big_endian_matrix(unitary_tq.data.numpy()) + + # phase? + phase = find_global_phase(unitary_tq, unitary_qiskit, 1e-4) + + assert np.allclose( + unitary_tq * phase, unitary_qiskit, atol=1e-6 + ), f"{pair} not equal with {params=}!" diff --git a/torchquantum/layer/general.py b/torchquantum/layer/general.py index 0a61aa29..50b2b0c1 100644 --- a/torchquantum/layer/general.py +++ b/torchquantum/layer/general.py @@ -31,12 +31,12 @@ Op2QAllLayer, RandomOp1All, ) +from torchquantum.operator.operators import R __all__ = [ "GlobalR", "GlobalRX", "GlobalRY", - "GlobalRZ", ] @@ -51,17 +51,13 @@ def __init__( ): """Create the layer""" super().__init__() - self.ops_all = tq.QuantumModuleList() self.n_wires = n_wires - self.ops_list = [ - {"name": "rot", "params": [phi, theta, 0], "wires": k} - for k in range(self.n_wires) - ] + self.params = torch.tensor([[theta, phi]]) @tq.static_support - def forward(self, q_device): - qmodule = tq.QuantumModule.from_op_history(self.ops_list) - qmodule(q_device) + def forward(self, q_device, x=None): + for k in range(self.n_wires): + R()(q_device, wires=k, params=self.params) class GlobalRX(GlobalR): From 9e201548c9e6159aac7de8fa61cf77eeb1bcef4e Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 17 Nov 2023 19:22:39 -0500 Subject: [PATCH 041/106] [minor] import fix --- torchquantum/layer/general.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/torchquantum/layer/general.py b/torchquantum/layer/general.py index 50b2b0c1..65847e23 100644 --- a/torchquantum/layer/general.py +++ b/torchquantum/layer/general.py @@ -31,7 +31,6 @@ Op2QAllLayer, RandomOp1All, ) -from torchquantum.operator.operators import R __all__ = [ "GlobalR", @@ -57,7 +56,7 @@ def __init__( @tq.static_support def forward(self, q_device, x=None): for k in range(self.n_wires): - R()(q_device, wires=k, params=self.params) + tq.R()(q_device, wires=k, params=self.params) class GlobalRX(GlobalR): From 46b04ca510d7c2b9656ae537e2b248d2bd2248de Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 17 Nov 2023 19:33:01 -0500 Subject: [PATCH 042/106] adding GRZ gate --- test/layers/test_rotgate.py | 5 +++-- torchquantum/layer/general.py | 21 +++++++++++++++++++++ 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/test/layers/test_rotgate.py b/test/layers/test_rotgate.py index beec6d72..c69d5569 100644 --- a/test/layers/test_rotgate.py +++ b/test/layers/test_rotgate.py @@ -7,13 +7,14 @@ find_global_phase, ) -from qiskit.circuit.library import GR, GRX, GRY +from qiskit.circuit.library import GR, GRX, GRY, GRZ import numpy as np all_pairs = [ - # {"qiskit": GR, "tq": tq.layer.GlobalR, "params": 2}, + {"qiskit": GR, "tq": tq.layer.GlobalR, "params": 2}, {"qiskit": GRX, "tq": tq.layer.GlobalRX, "params": 1}, {"qiskit": GRY, "tq": tq.layer.GlobalRY, "params": 1}, + {"qiskit": GRZ, "tq": tq.layer.GlobalRZ, "params": 1}, ] ITERATIONS = 10 diff --git a/torchquantum/layer/general.py b/torchquantum/layer/general.py index 65847e23..9857220a 100644 --- a/torchquantum/layer/general.py +++ b/torchquantum/layer/general.py @@ -36,6 +36,7 @@ "GlobalR", "GlobalRX", "GlobalRY", + "GlobalRZ", ] @@ -81,3 +82,23 @@ def __init__( ): """Create the layer""" super().__init__(n_wires, theta, phi=torch.pi / 2) + +class GlobalRZ(tq.QuantumModule): + """Layer Template for a Global RZ General Gate""" + + def __init__( + self, + n_wires: int = 0, + phi: float = 0, + ): + """Create the layer""" + super().__init__() + self.n_wires = n_wires + self.params = torch.tensor([[phi]]) + + @tq.static_support + def forward(self, q_device, x=None): + for k in range(self.n_wires): + tq.RZ()(q_device, wires=k, params=self.params) + + From 931233743c01577ba67efabc15cd4166e3d432db Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 12:45:34 -0500 Subject: [PATCH 043/106] added tests and slight modification to rotation --- .github/workflows/example_tests.yaml | 15 ++++++++++++++- examples/qubit_rotation/qubit_rotation.py | 14 +++++++++++--- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index d8db7db3..6cf931f4 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -29,4 +29,17 @@ jobs: if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Test Examples run: | - python3 examples/qubit_rotation/qubit_rotation.py + python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 + python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 + python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 + python3 examples/train_state_prep/train_state_prep.py --epochs 1 + python3 examples/superdense_coding/superdense_coding_torchquantum.py + python3 examples/regression/run_regression.py --epochs 1 + python3 examples/param_shift_onchip_training/param_shift.py + python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 + python3 examples/hadamard_grad/circ.py + python3 examples/encoder_examples/encoder_8x2ry.py + python3 examples/converter_tq_qiskit/convert.py + python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 + python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 + python3 examples/PauliSumOp/pauli_sum_op.py diff --git a/examples/qubit_rotation/qubit_rotation.py b/examples/qubit_rotation/qubit_rotation.py index be2dfc82..bae1e803 100644 --- a/examples/qubit_rotation/qubit_rotation.py +++ b/examples/qubit_rotation/qubit_rotation.py @@ -6,6 +6,7 @@ import torchquantum as tq import torch from torchquantum.measurement import expval_joint_analytical +import argparse class OptimizationModel(torch.nn.Module): @@ -42,7 +43,7 @@ def train(model, device, optimizer): # main function to run the optimization -def main(): +def main(n_epochs): seed = 0 torch.manual_seed(seed) @@ -50,7 +51,6 @@ def main(): device = torch.device("cuda" if use_cuda else "cpu") model = OptimizationModel() - n_epochs = 200 optimizer = torch.optim.SGD(model.parameters(), lr=0.1) for epoch in range(1, n_epochs + 1): @@ -65,4 +65,12 @@ def main(): if __name__ == "__main__": - main() + parser = argparse.ArgumentParser( + prog="Qubit Rotation", + description="Specify Parameters for Qubit Rotation Optimization Example", + ) + parser.add_argument( + "--epochs", type=int, default=200, help="number of training epochs" + ) + args = parser.parse_args() + main(args.epochs) From beef18260daa53263cb20ba032cce1075873a3a9 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 15:57:53 -0500 Subject: [PATCH 044/106] [minor] fix path to h2.txt file for vqe --- examples/vqe/new_simple_vqe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/vqe/new_simple_vqe.py b/examples/vqe/new_simple_vqe.py index b5a83953..31cab355 100644 --- a/examples/vqe/new_simple_vqe.py +++ b/examples/vqe/new_simple_vqe.py @@ -30,7 +30,7 @@ from torchquantum.plugin import qiskit2tq_op_history if __name__ == "__main__": - hamil = Hamiltonian.from_file("./examples/simple_vqe/h2.txt") + hamil = Hamiltonian.from_file("./examples/vqe/h2.txt") ops = [ {'name': 'u3', 'wires': 0, 'trainable': True}, From 12a552ae1bf397a799fc9248fa03887081a44d13 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:07:10 -0500 Subject: [PATCH 045/106] [minor] updated to fully handle not having qiskit --- .github/workflows/example_tests.yaml | 1 + examples/regression/new_run_regression.py | 5 ++--- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index 6cf931f4..e5f7425c 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -43,3 +43,4 @@ jobs: python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 python3 examples/PauliSumOp/pauli_sum_op.py + python3 examples/regression/new_run_regression.py --epochs 1 diff --git a/examples/regression/new_run_regression.py b/examples/regression/new_run_regression.py index fdeb5cd4..30fc3aa7 100644 --- a/examples/regression/new_run_regression.py +++ b/examples/regression/new_run_regression.py @@ -305,12 +305,11 @@ def main(): model.set_qiskit_processor(processor_simulation) valid_test(dataflow, q_device, "test", model, device, qiskit=True) + # final valid + valid_test(dataflow, q_device, "valid", model, device, True) except: pass - # final valid - valid_test(dataflow, q_device, "valid", model, device, True) - if __name__ == "__main__": main() From 4565221f9b2e32f349d3d269c913c0008b501217 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:28:15 -0500 Subject: [PATCH 046/106] [minor] added a missing layer --- .github/workflows/example_tests.yaml | 1 + torchquantum/layer/layers.py | 1 + 2 files changed, 2 insertions(+) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index e5f7425c..580e7f14 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -44,3 +44,4 @@ jobs: python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 python3 examples/PauliSumOp/pauli_sum_op.py python3 examples/regression/new_run_regression.py --epochs 1 + python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index 9f129acc..c7be23c4 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -51,6 +51,7 @@ "CXCXCXLayer", "SWAPSWAPLayer", "RXYZCXLayer0", + "U3CU3Layer0", "QFTLayer", ] From 83345b4d133d73cea760464f28870d31d1efdf8d Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:34:35 -0500 Subject: [PATCH 047/106] [minor] fixed grover example dependency --- .github/workflows/example_tests.yaml | 1 + examples/grover/grover_example_sudoku.py | 4 ++-- torchquantum/algorithm/__init__.py | 1 + 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index 580e7f14..9ee0ea2e 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -45,3 +45,4 @@ jobs: python3 examples/PauliSumOp/pauli_sum_op.py python3 examples/regression/new_run_regression.py --epochs 1 python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 + python3 examples/grover/grover_example_sudoku.py diff --git a/examples/grover/grover_example_sudoku.py b/examples/grover/grover_example_sudoku.py index 25761594..4969eea2 100644 --- a/examples/grover/grover_example_sudoku.py +++ b/examples/grover/grover_example_sudoku.py @@ -28,7 +28,7 @@ """ import torchquantum as tq -from torchquantum.algorithms import Grover +from torchquantum.algorithm import Grover # To simplify the process, we can compile this set of comparisons into a list of clauses for convenience. @@ -90,4 +90,4 @@ def XOR(input0, input1, output): print("b = ", key[1]) print("c = ", key[2]) print("d = ", key[3]) - print("") \ No newline at end of file + print("") diff --git a/torchquantum/algorithm/__init__.py b/torchquantum/algorithm/__init__.py index 623d71b7..7dfb672a 100644 --- a/torchquantum/algorithm/__init__.py +++ b/torchquantum/algorithm/__init__.py @@ -25,3 +25,4 @@ from .vqe import * from .hamiltonian import * from .qft import * +from .grover import * From 16376803f5be001983dbb4358d9ef3793a1dc9b4 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:44:51 -0500 Subject: [PATCH 048/106] [minor] adding imports for pulse --- examples/optimal_control/optimal_control.py | 2 +- examples/optimal_control/optimal_control_gaussian.py | 2 +- examples/optimal_control/optimal_control_multi_qubit.py | 6 +++--- torchquantum/__init__.py | 1 + torchquantum/pulse/__init__.py | 1 + 5 files changed, 7 insertions(+), 5 deletions(-) diff --git a/examples/optimal_control/optimal_control.py b/examples/optimal_control/optimal_control.py index 438e135b..89601153 100644 --- a/examples/optimal_control/optimal_control.py +++ b/examples/optimal_control/optimal_control.py @@ -41,7 +41,7 @@ dtype=torch.complex64, ) - pulse = tq.QuantumPulseDirect(n_steps=4, hamil=[[0, 1], [1, 0]]) + pulse = tq.pulse.QuantumPulseDirect(n_steps=4, hamil=[[0, 1], [1, 0]]) optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) diff --git a/examples/optimal_control/optimal_control_gaussian.py b/examples/optimal_control/optimal_control_gaussian.py index 861cc92a..559e6127 100644 --- a/examples/optimal_control/optimal_control_gaussian.py +++ b/examples/optimal_control/optimal_control_gaussian.py @@ -41,7 +41,7 @@ dtype=torch.complex64, ) - pulse = tq.QuantumPulseGaussian(hamil=[[0, 1], [1, 0]]) + pulse = tq.pulse.QuantumPulseGaussian(hamil=[[0, 1], [1, 0]]) optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) diff --git a/examples/optimal_control/optimal_control_multi_qubit.py b/examples/optimal_control/optimal_control_multi_qubit.py index 023d4f3c..148b526c 100644 --- a/examples/optimal_control/optimal_control_multi_qubit.py +++ b/examples/optimal_control/optimal_control_multi_qubit.py @@ -43,9 +43,9 @@ dtype=torch.complex64, ) - pulse_q0 = tq.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) - pulse_q1 = tq.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) - pulse_q01 = tq.QuantumPulseDirect( + pulse_q0 = tq.pulse.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) + pulse_q1 = tq.pulse.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) + pulse_q01 = tq.pulse.QuantumPulseDirect( n_steps=10, hamil=[ [1, 0, 0, 0], diff --git a/torchquantum/__init__.py b/torchquantum/__init__.py index c8aed9ed..b1529623 100644 --- a/torchquantum/__init__.py +++ b/torchquantum/__init__.py @@ -38,6 +38,7 @@ from .noise_model import * from .algorithm import * from .dataset import * +from .pulse import * # here we check whether the Qiskit parameterization bug is fixed, if not, a # warning message will be printed diff --git a/torchquantum/pulse/__init__.py b/torchquantum/pulse/__init__.py index 5a4539de..d281a73f 100644 --- a/torchquantum/pulse/__init__.py +++ b/torchquantum/pulse/__init__.py @@ -25,4 +25,5 @@ from .utils import * from .sesolve import sesolve from .mesolve import mesolve +from .pulses import * # from .smesolve import smesolve From 60b055f0ff96c38488f97cff66a93e7cf9041afc Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:47:19 -0500 Subject: [PATCH 049/106] [minor] fixed typo in save_load --- examples/save_load_example/save_load.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/save_load_example/save_load.py b/examples/save_load_example/save_load.py index 1022c3aa..c5a6c57a 100644 --- a/examples/save_load_example/save_load.py +++ b/examples/save_load_example/save_load.py @@ -143,7 +143,7 @@ def save_load3(): # print(model.q_layer.rx0._parameters) traced_cell = torch.jit.trace(model, (x)) - torch.jit.save(traced_cell, "model_trace.pth") + torch.jit.save(traced_cell, "model_trace.pt") loaded_trace = torch.jit.load("model_trace.pt") y2 = loaded_trace(x) From 52391de372fa358137010a0574d8d087e8ffb394 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 17:15:05 -0500 Subject: [PATCH 050/106] [minor] added test + fixed layer import --- .github/workflows/example_tests.yaml | 1 + torchquantum/layer/layers.py | 1 + 2 files changed, 2 insertions(+) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index 9ee0ea2e..8d0f1df6 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -46,3 +46,4 @@ jobs: python3 examples/regression/new_run_regression.py --epochs 1 python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 python3 examples/grover/grover_example_sudoku.py + python3 examples/param_shift_onchip_training/param_shift.py diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index c7be23c4..9d4e5f61 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -53,6 +53,7 @@ "RXYZCXLayer0", "U3CU3Layer0", "QFTLayer", + "SethLayer0", ] From 2da85e50c1500d0d53765e06fb04f57ef1bf3efc Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 19:53:50 -0500 Subject: [PATCH 051/106] updates to paulitwodesign, structure of twolocal circuits, and tests for twolocal --- test/layers/test_nlocal.py | 91 ++++++++++--------- torchquantum/layer/layers.py | 18 +--- torchquantum/layer/nlocal/efficient_su2.py | 4 +- .../layer/nlocal/excitation_preserving.py | 4 +- torchquantum/layer/nlocal/pauli_two.py | 4 +- torchquantum/layer/nlocal/real_amplitudes.py | 4 +- torchquantum/layer/nlocal/two_local.py | 24 ++++- 7 files changed, 82 insertions(+), 67 deletions(-) diff --git a/test/layers/test_nlocal.py b/test/layers/test_nlocal.py index 57f019f4..99a5d12c 100644 --- a/test/layers/test_nlocal.py +++ b/test/layers/test_nlocal.py @@ -29,9 +29,9 @@ def compare_tq_to_qiskit(tq_circuit, qiskit_circuit, instance_info = ""): for op in tq_circuit.op_history ] - # create tuples (NOTE: WILL LOSE ORDER SO NOT ENTIRELY CORRECT) - tq_ops_tuple = {tuple(op) for op in tq_ops} - qiskit_ops_tuple = {tuple(op) for op in qiskit_ops} + # create tuples, preserving order + tq_ops_tuple = [tuple(op) for op in tq_ops] + qiskit_ops_tuple = [tuple(op) for op in qiskit_ops] # assert if they are the same assert len(tq_ops) == len( @@ -43,51 +43,54 @@ def compare_tq_to_qiskit(tq_circuit, qiskit_circuit, instance_info = ""): ## TEST TWOLOCAL -# iterate through different parameters to test -for entanglement_type in ("linear", "circular", "full"): - for n_wires in (3, 5, 10): - for reps in range(1, 5): - # create the TQ circuit - tq_two = tq.layer.TwoLocal( - [tq.RY, tq.RZ], - [tq.CZ], - arch={"n_wires": n_wires}, - entanglement_layer=entanglement_type, - reps=reps, - ) - qdev = tq.QuantumDevice(n_wires, record_op=True) - tq_two(qdev) +def test_twolocal(): + # iterate through different parameters to test + for entanglement_type in ("linear", "circular", "full"): + for n_wires in (3, 5, 10): + for reps in range(1, 5): + # create the TQ circuit + tq_two = tq.layer.TwoLocal( + n_wires, + ["ry", "rz"], + "cz", + entanglement_layer=entanglement_type, + reps=reps, + ) + qdev = tq.QuantumDevice(n_wires, record_op=True) + tq_two(qdev) - # create the qiskit circuit - qiskit_two = TwoLocal( - n_wires, - ["ry", "rz"], - "cz", - entanglement_type, - reps=reps, - insert_barriers=False, - ) - - # compare the circuits - test_info = f"{entanglement_type} with {n_wires} wires and {reps} reps" - compare_tq_to_qiskit(qdev, qiskit_two) + # create the qiskit circuit + qiskit_two = TwoLocal( + n_wires, + ["ry", "rz"], + "cz", + entanglement_type, + reps=reps, + insert_barriers=False, + ) + + # compare the circuits + test_info = f"{entanglement_type} with {n_wires} wires and {reps} reps" + compare_tq_to_qiskit(qdev, qiskit_two) ## TEST OTHER CIRCUITS -tq_to_qiskit = { - "EfficientSU2": (tq.layer.EfficientSU2, EfficientSU2), - "ExcitationPreserving": (tq.layer.ExcitationPreserving, ExcitationPreserving), - "RealAmplitudes": (tq.layer.RealAmplitudes, RealAmplitudes), -} +def test_twolocal_variants(): + tq_to_qiskit = { + "EfficientSU2": (tq.layer.EfficientSU2, EfficientSU2), + "ExcitationPreserving": (tq.layer.ExcitationPreserving, ExcitationPreserving), + "RealAmplitudes": (tq.layer.RealAmplitudes, RealAmplitudes), + "PauliTwo": (tq.layer.PauliTwoDesign, PauliTwoDesign), + } -# run all the tests -for circuit_name in tq_to_qiskit: - tq_instance, qiskit_instance = tq_to_qiskit[circuit_name] - for n_wires in range(2, 5): - tq_circuit = tq_instance({"n_wires": n_wires}) - circuit = qiskit_instance(n_wires) - qdev = tq.QuantumDevice(n_wires, record_op=True) - tq_circuit(qdev) - compare_tq_to_qiskit(qdev, circuit, f"{circuit_name} with {n_wires} wires") + # run all the tests + for circuit_name in tq_to_qiskit: + tq_instance, qiskit_instance = tq_to_qiskit[circuit_name] + for n_wires in range(2, 5): + tq_circuit = tq_instance(n_wires) + circuit = qiskit_instance(n_wires) + qdev = tq.QuantumDevice(n_wires, record_op=True) + tq_circuit(qdev) + compare_tq_to_qiskit(qdev, circuit, f"{circuit_name} with {n_wires} wires") diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index bd88fb13..e545014b 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -230,7 +230,7 @@ def forward(self, q_device: tq.QuantumDevice): class RandomOp1All(tq.QuantumModule): def __init__( - self, n_wires: int, op_types=(tq.RX, tq.RY, tq.RZ), op_ratios=None, seed=None + self, n_wires: int, op_types=(tq.RX, tq.RY, tq.RZ), op_ratios=None, has_params=True, trainable=True, seed=None ): """Layer adding a random gate to all wires @@ -246,26 +246,18 @@ def __init__( self.op_ratios = op_ratios self.seed = seed self.gate_all = nn.ModuleList() + if seed is not None: np.random.seed(seed) - self.build_random_layer() - def build_random_layer(self): for k in range(self.n_wires): op = np.random.choice(self.op_types, p=self.op_ratios) - self.gate_all.append(op()) + self.gate_all.append(op(has_params=has_params, trainable=trainable)) @tq.static_support - def forward(self, q_device: tq.QuantumDevice, x): - # op on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of gates ({self.n_wires}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - + def forward(self, q_device: tq.QuantumDevice): for k in range(self.n_wires): - self.gate_all[k](q_device, wires=k, params=x[:, k]) + self.gate_all[k](q_device, wires=k) class RandomLayer(tq.QuantumModule): diff --git a/torchquantum/layer/nlocal/efficient_su2.py b/torchquantum/layer/nlocal/efficient_su2.py index 27a2e0d7..4bd7cf27 100644 --- a/torchquantum/layer/nlocal/efficient_su2.py +++ b/torchquantum/layer/nlocal/efficient_su2.py @@ -42,14 +42,14 @@ class EfficientSU2(TwoLocal): def __init__( self, - arch: dict = None, + n_wires: int = None, entanglement_layer: str = "reverse_linear", reps: int = 3, skip_final_rotation_layer: bool = False, ): # construct circuit with rotation layers of RY and RZ and entanglement with CX super().__init__( - arch=arch, + n_wires = n_wires, rotation_ops=[tq.RY, tq.RZ], entanglement_ops=[tq.CNOT], entanglement_layer=entanglement_layer, diff --git a/torchquantum/layer/nlocal/excitation_preserving.py b/torchquantum/layer/nlocal/excitation_preserving.py index 4fa576ca..f2e04742 100644 --- a/torchquantum/layer/nlocal/excitation_preserving.py +++ b/torchquantum/layer/nlocal/excitation_preserving.py @@ -42,14 +42,14 @@ class ExcitationPreserving(TwoLocal): def __init__( self, - arch: dict = None, + n_wires: int = 1, entanglement_layer: str = "full", reps: int = 3, skip_final_rotation_layer: bool = False, ): # construct circuit with rotation layers of RZ and entanglement with RXX and RYY super().__init__( - arch=arch, + n_wires = n_wires, rotation_ops=[tq.RZ], entanglement_ops=[tq.RXX, tq.RYY], entanglement_layer=entanglement_layer, diff --git a/torchquantum/layer/nlocal/pauli_two.py b/torchquantum/layer/nlocal/pauli_two.py index 4b55b052..f7db424b 100644 --- a/torchquantum/layer/nlocal/pauli_two.py +++ b/torchquantum/layer/nlocal/pauli_two.py @@ -44,7 +44,7 @@ class PauliTwoDesign(TwoLocal): def __init__( self, - arch: dict = None, + n_wires: int = 1, entanglement_layer: str = "reverse_linear", reps: int = 3, skip_final_rotation_layer: bool = False, @@ -54,7 +54,7 @@ def __init__( self.seed = seed # construct circuit with entanglement with CX super().__init__( - arch=arch, + n_wires=n_wires, entanglement_ops=[tq.CNOT], entanglement_layer=entanglement_layer, reps=reps, diff --git a/torchquantum/layer/nlocal/real_amplitudes.py b/torchquantum/layer/nlocal/real_amplitudes.py index bcece049..f7b66f16 100644 --- a/torchquantum/layer/nlocal/real_amplitudes.py +++ b/torchquantum/layer/nlocal/real_amplitudes.py @@ -42,14 +42,14 @@ class RealAmplitudes(TwoLocal): def __init__( self, - arch: dict = None, + n_wires: int = 1, entanglement_layer: str = "reverse_linear", reps: int = 3, skip_final_rotation_layer: bool = False, ): # construct circuit with rotation layers of RY and entanglement with CX super().__init__( - arch=arch, + n_wires=n_wires, rotation_ops=[tq.RY], entanglement_ops=[tq.CNOT], entanglement_layer=entanglement_layer, diff --git a/torchquantum/layer/nlocal/two_local.py b/torchquantum/layer/nlocal/two_local.py index 23c976c9..2df63806 100644 --- a/torchquantum/layer/nlocal/two_local.py +++ b/torchquantum/layer/nlocal/two_local.py @@ -28,7 +28,9 @@ Op2QAllLayer, Op2QDenseLayer, ) +from torchquantum.operator import op_name_dict from .nlocal import NLocal +from collections.abc import Iterable __all__ = [ "TwoLocal", @@ -52,9 +54,9 @@ class TwoLocal(NLocal): def __init__( self, + n_wires: int = 1, rotation_ops: list = None, entanglement_ops: list = None, - arch: dict = None, rotation_layer: tq.QuantumModule = Op1QAllLayer, entanglement_layer: str = "linear", reps: int = 1, @@ -74,9 +76,27 @@ def __init__( elif entanglement_layer == "full": entanglement_layer = Op2QDenseLayer + # handling different input types for the rotation ops + if isinstance(rotation_ops, str): + rotation_ops = [op_name_dict[rotation_ops]] + elif isinstance(rotation_ops, Iterable): + if all(isinstance(rot, str) for rot in rotation_ops): + rotation_ops = [op_name_dict[rot] for rot in rotation_ops] + else: + rotation_ops = [rotation_ops] + + # handling different input types for the entanglment ops + if isinstance(entanglement_ops, str): + entanglement_ops = [op_name_dict[entanglement_ops]] + elif isinstance(entanglement_ops, Iterable): + if all(isinstance(op, str) for op in entanglement_ops): + entanglement_ops = [op_name_dict[op] for op in entanglement_ops] + else: + entanglement_ops = [entanglement_ops] + # initialize super().__init__( - arch=arch, + arch={"n_wires": n_wires}, rotation_ops=rotation_ops, rotation_layer=rotation_layer, rotation_layer_params={"has_params": True, "trainable": True}, From e5cdd52e8237d7251bc20cf7a44761ecb7181ca6 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 19:58:15 -0500 Subject: [PATCH 052/106] removing extraneous file --- test/layers/test_layers.py | 37 ------------------------------------- 1 file changed, 37 deletions(-) delete mode 100644 test/layers/test_layers.py diff --git a/test/layers/test_layers.py b/test/layers/test_layers.py deleted file mode 100644 index 760dc46e..00000000 --- a/test/layers/test_layers.py +++ /dev/null @@ -1,37 +0,0 @@ -import torchquantum as tq -from qiskit.circuit.library import TwoLocal - -for entanglement_type in ("linear", "circular", "full"): - for n_wires in (3, 5, 10): - for reps in range(5): - - # create the TQ circuit - two2 = tq.layer.TwoLocal([tq.RY, tq.RZ], [tq.CZ], arch={"n_wires": n_wires}, entanglement_layer=entanglement_type, reps=reps) - qdev = tq.QuantumDevice(n_wires, record_op=True) - two2(qdev) - - # create the qiskit circuit - two = TwoLocal(n_wires, ['ry','rz'], 'cz', entanglement_type, reps=reps, insert_barriers=False) - operations = [] - for bit in two.decompose(): - wires = [] - for qu in bit.qubits: - wires.append(qu.index) - operations.append({ - "name": bit.operation.name, - "wires": tuple(wires), - }) - - # create operations list - qiskit_ops = operations - tq_ops = ([{"name": op["name"], "wires": (op["wires"],) if isinstance(op["wires"], int) else tuple(op["wires"])} for op in qdev.op_history]) - - # create tuples (NOTE: WILL LOSE ORDER SO NOT ENTIRELY CORRECT) - tq_ops_tuple = {tuple(op) for op in tq_ops} - qiskit_ops_tuple = {tuple(op) for op in qiskit_ops} - - # assert if they are the same - test_info = f"{entanglement_type} with {n_wires} wires and {reps} reps" - assert len(tq_ops) == len(qiskit_ops), f"operations are varying lengths for {test_info}" - assert tq_ops_tuple == qiskit_ops_tuple, f"operations do not match for {test_info}" - From 33bfb85db365951a0ae7e97504db19356128f256 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 19:59:56 -0500 Subject: [PATCH 053/106] [minor] style update --- test/layers/test_nlocal.py | 19 +- torchquantum/layer/layers.py | 786 +++++++++--------- torchquantum/layer/nlocal/efficient_su2.py | 2 +- .../layer/nlocal/excitation_preserving.py | 2 +- 4 files changed, 424 insertions(+), 385 deletions(-) diff --git a/test/layers/test_nlocal.py b/test/layers/test_nlocal.py index 99a5d12c..62387190 100644 --- a/test/layers/test_nlocal.py +++ b/test/layers/test_nlocal.py @@ -1,11 +1,18 @@ import torchquantum as tq -from qiskit.circuit.library import TwoLocal, EfficientSU2, ExcitationPreserving, PauliTwoDesign, RealAmplitudes +from qiskit.circuit.library import ( + TwoLocal, + EfficientSU2, + ExcitationPreserving, + PauliTwoDesign, + RealAmplitudes, +) -def compare_tq_to_qiskit(tq_circuit, qiskit_circuit, instance_info = ""): + +def compare_tq_to_qiskit(tq_circuit, qiskit_circuit, instance_info=""): """ helper function to compare if tq and qiskit have the same gates configuration """ - + qiskit_ops = [] for bit in qiskit_circuit.decompose(): wires = [] @@ -41,8 +48,10 @@ def compare_tq_to_qiskit(tq_circuit, qiskit_circuit, instance_info = ""): tq_ops_tuple == qiskit_ops_tuple ), f"operations do not match for {instance_info}" + ## TEST TWOLOCAL + def test_twolocal(): # iterate through different parameters to test for entanglement_type in ("linear", "circular", "full"): @@ -68,7 +77,7 @@ def test_twolocal(): reps=reps, insert_barriers=False, ) - + # compare the circuits test_info = f"{entanglement_type} with {n_wires} wires and {reps} reps" compare_tq_to_qiskit(qdev, qiskit_two) @@ -76,6 +85,7 @@ def test_twolocal(): ## TEST OTHER CIRCUITS + def test_twolocal_variants(): tq_to_qiskit = { "EfficientSU2": (tq.layer.EfficientSU2, EfficientSU2), @@ -93,4 +103,3 @@ def test_twolocal_variants(): qdev = tq.QuantumDevice(n_wires, record_op=True) tq_circuit(qdev) compare_tq_to_qiskit(qdev, circuit, f"{circuit_name} with {n_wires} wires") - diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py index e545014b..f10cea16 100644 --- a/torchquantum/layer/layers.py +++ b/torchquantum/layer/layers.py @@ -58,10 +58,11 @@ class QuantumModuleFromOps(tq.QuantumModule): """Initializes a QuantumModuleFromOps instance. - Args: - ops (List[tq.Operation]): List of quantum operations. + Args: + ops (List[tq.Operation]): List of quantum operations. + + """ - """ def __init__(self, ops): super().__init__() self.ops = tq.QuantumModuleList(ops) @@ -70,13 +71,13 @@ def __init__(self, ops): def forward(self, q_device: tq.QuantumDevice): """Performs the forward pass of the quantum module. - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. - Returns: - None + Returns: + None - """ + """ self.q_device = q_device for op in self.ops: op(q_device) @@ -111,18 +112,19 @@ def forward(self, q_device: tq.QuantumDevice): class ClassicalInOpAll(tq.QuantumModule): """ - Quantum module that applies the same quantum operation to all wires of a quantum device, - where the parameters of the operation are obtained from a classical input. + Quantum module that applies the same quantum operation to all wires of a quantum device, + where the parameters of the operation are obtained from a classical input. - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. + Args: + n_gate (int): Number of gates. + op (tq.Operator): Quantum operation to be applied. - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. + Attributes: + n_gate (int): Number of gates. + gate_all (nn.ModuleList): List of quantum operations. + + """ - """ def __init__(self, n_gate: int, op: tq.Operator): super().__init__() self.n_gate = n_gate @@ -133,19 +135,19 @@ def __init__(self, n_gate: int, op: tq.Operator): @tq.static_support def forward(self, q_device: tq.QuantumDevice, x): """ - Performs the forward pass of the classical input quantum operation module. + Performs the forward pass of the classical input quantum operation module. - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - x (torch.Tensor): Classical input of shape (batch_size, n_gate). + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. + x (torch.Tensor): Classical input of shape (batch_size, n_gate). - Returns: - None + Returns: + None - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. + Raises: + AssertionError: If the number of gates is different from the number of wires in the device. - """ + """ # rx on all wires, assert the number of gate is the same as the number # of wires in the device. assert self.n_gate == q_device.n_wires, ( @@ -159,17 +161,18 @@ def forward(self, q_device: tq.QuantumDevice, x): class FixedOpAll(tq.QuantumModule): """ - Quantum module that applies the same fixed quantum operation to all wires of a quantum device. + Quantum module that applies the same fixed quantum operation to all wires of a quantum device. + + Args: + n_gate (int): Number of gates. + op (tq.Operator): Quantum operation to be applied. - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. + Attributes: + n_gate (int): Number of gates. + gate_all (nn.ModuleList): List of quantum operations. - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. + """ - """ def __init__(self, n_gate: int, op: tq.Operator): super().__init__() self.n_gate = n_gate @@ -180,18 +183,18 @@ def __init__(self, n_gate: int, op: tq.Operator): @tq.static_support def forward(self, q_device: tq.QuantumDevice): """ - Performs the forward pass of the fixed quantum operation module. + Performs the forward pass of the fixed quantum operation module. - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. - Returns: - None + Returns: + None - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. + Raises: + AssertionError: If the number of gates is different from the number of wires in the device. - """ + """ # rx on all wires, assert the number of gate is the same as the number # of wires in the device. assert self.n_gate == q_device.n_wires, ( @@ -205,17 +208,18 @@ def forward(self, q_device: tq.QuantumDevice): class TwoQAll(tq.QuantumModule): """ - Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. + Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. - Args: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation to be applied. + Args: + n_gate (int): Number of adjacent pairs of wires. + op (tq.Operator): Two-qubit quantum operation to be applied. - Attributes: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation. + Attributes: + n_gate (int): Number of adjacent pairs of wires. + op (tq.Operator): Two-qubit quantum operation. + + """ - """ def __init__(self, n_gate: int, op: tq.Operator): super().__init__() self.n_gate = n_gate @@ -230,7 +234,13 @@ def forward(self, q_device: tq.QuantumDevice): class RandomOp1All(tq.QuantumModule): def __init__( - self, n_wires: int, op_types=(tq.RX, tq.RY, tq.RZ), op_ratios=None, has_params=True, trainable=True, seed=None + self, + n_wires: int, + op_types=(tq.RX, tq.RY, tq.RZ), + op_ratios=None, + has_params=True, + trainable=True, + seed=None, ): """Layer adding a random gate to all wires @@ -262,28 +272,29 @@ def forward(self, q_device: tq.QuantumDevice): class RandomLayer(tq.QuantumModule): """ - Quantum module that represents a random layer of quantum operations applied to specified wires. + Quantum module that represents a random layer of quantum operations applied to specified wires. + + Args: + wires (int or Iterable[int]): Indices of the wires the operations are applied to. + n_ops (int): Number of random operations in the layer. + n_params (int): Number of parameters for each random operation. + op_ratios (list or float): Ratios determining the relative frequencies of different operation types. + op_types (tuple or tq.Operator): Types of random operations to be included in the layer. + seed (int): Seed for random number generation. + qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. + + Attributes: + n_ops (int): Number of random operations in the layer. + n_params (int): Number of parameters for each random operation. + wires (list): Indices of the wires the operations are applied to. + n_wires (int): Number of wires. + op_types (list): Types of random operations included in the layer. + op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. + seed (int): Seed for random number generation. + op_list (tq.QuantumModuleList): List of random operations in the layer. - Args: - wires (int or Iterable[int]): Indices of the wires the operations are applied to. - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - op_ratios (list or float): Ratios determining the relative frequencies of different operation types. - op_types (tuple or tq.Operator): Types of random operations to be included in the layer. - seed (int): Seed for random number generation. - qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. - - Attributes: - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - wires (list): Indices of the wires the operations are applied to. - n_wires (int): Number of wires. - op_types (list): Types of random operations included in the layer. - op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. - seed (int): Seed for random number generation. - op_list (tq.QuantumModuleList): List of random operations in the layer. + """ - """ def __init__( self, wires, @@ -334,15 +345,15 @@ def __init__( def rebuild_random_layer_from_op_list(self, n_ops_in, wires_in, op_list_in): """ - Rebuilds a random layer from the given operation list. - This method is used for loading a random layer from a checkpoint. + Rebuilds a random layer from the given operation list. + This method is used for loading a random layer from a checkpoint. - Args: - n_ops_in (int): Number of operations in the layer. - wires_in (list): Indices of the wires the operations are applied to. - op_list_in (list): List of operations in the layer. + Args: + n_ops_in (int): Number of operations in the layer. + wires_in (list): Indices of the wires the operations are applied to. + op_list_in (list): List of operations in the layer. - """ + """ self.n_ops = n_ops_in self.wires = wires_in @@ -413,20 +424,21 @@ def forward(self, q_device: tq.QuantumDevice): class RandomLayerAllTypes(RandomLayer): """ - Random layer with a wide range of quantum gate types. + Random layer with a wide range of quantum gate types. + + This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. - This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. + Args: + wires (int or list): Indices of the wires the operations are applied to. + n_ops (int): Number of operations in the layer. + n_params (int): Number of parameters for each operation. + op_ratios (list): Ratios for selecting different types of operations. + op_types (tuple): Types of operations to include in the layer. + seed (int): Seed for the random number generator. + qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. - Args: - wires (int or list): Indices of the wires the operations are applied to. - n_ops (int): Number of operations in the layer. - n_params (int): Number of parameters for each operation. - op_ratios (list): Ratios for selecting different types of operations. - op_types (tuple): Types of operations to include in the layer. - seed (int): Seed for the random number generator. - qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. + """ - """ def __init__( self, wires, @@ -481,14 +493,15 @@ def __init__( class SimpleQLayer(tq.QuantumModule): """ - Simple quantum layer consisting of three parameterized gates applied to specific wires. + Simple quantum layer consisting of three parameterized gates applied to specific wires. - This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. + This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. + + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -508,14 +521,15 @@ def forward(self, q_dev): class CXLayer(tq.QuantumModule): """ - Quantum layer with a controlled-X (CX) gate applied to two specified wires. + Quantum layer with a controlled-X (CX) gate applied to two specified wires. - This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. + This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. + + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -528,14 +542,15 @@ def forward(self, q_dev): class CXCXCXLayer(tq.QuantumModule): """ - Quantum layer with a sequence of CX gates applied to three specified wires. + Quantum layer with a sequence of CX gates applied to three specified wires. + + This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. - This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -550,14 +565,15 @@ def forward(self, q_dev): class SWAPSWAPLayer(tq.QuantumModule): """ - Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. + Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. + + This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. - This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. + Args: + n_wires (int): Number of wires in the quantum device. - Args: - n_wires (int): Number of wires in the quantum device. + """ - """ def __init__(self, n_wires): super().__init__() self.n_wires = n_wires @@ -571,17 +587,18 @@ def forward(self, q_dev): class Op1QAllLayer(tq.QuantumModule): """ - Quantum layer applying the same single-qubit operation to all wires. + Quantum layer applying the same single-qubit operation to all wires. - This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. + This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. - Args: - op (tq.Operator): Single-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + Args: + op (tq.Operator): Single-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + + """ - """ def __init__(self, op, n_wires: int, has_params=False, trainable=False): super().__init__() self.n_wires = n_wires @@ -598,21 +615,22 @@ def forward(self, q_device): class Op2QAllLayer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the - specified jump. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the + specified jump. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. """ + """pattern: circular = False jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] @@ -667,20 +685,21 @@ def forward(self, q_device): class Op2QFit32Layer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ - """ def __init__( self, op, @@ -720,18 +739,19 @@ def forward(self, q_device): class Op2QButterflyLayer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation in a butterfly pattern. + Quantum layer applying the same two-qubit operation in a butterfly pattern. - This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. + This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ - """ """pattern: [0, 5], [1, 4], [2, 3]""" def __init__( @@ -758,18 +778,19 @@ def forward(self, q_device): class Op2QDenseLayer(tq.QuantumModule): """ - Quantum layer applying the same two-qubit operation in a dense pattern. + Quantum layer applying the same two-qubit operation in a dense pattern. + + This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. - This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + """ - """ """pattern: [0, 1], [0, 2], [0, 3], [0, 4], [0, 5] [1, 2], [1, 3], [1, 4], [1, 5] @@ -805,23 +826,24 @@ def forward(self, q_device): class LayerTemplate0(tq.QuantumModule): """ - A template for a custom quantum layer. + A template for a custom quantum layer. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. (Optional) - n_layers_per_block (int): The number of layers per block. (Optional) - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. (Optional) + n_layers_per_block (int): The number of layers per block. (Optional) + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Abstract method to build the layers of the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Abstract method to build the layers of the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def __init__(self, arch: dict = None): super().__init__() self.n_wires = arch["n_wires"] @@ -844,25 +866,24 @@ def forward(self, q_device: tq.QuantumDevice): class U3CU3Layer0(LayerTemplate0): """ - Layer template with U3 and CU3 blocks. + Layer template with U3 and CU3 blocks. - This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. + This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the U3 and CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ + Methods: + build_layers: Builds the U3 and CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -887,25 +908,24 @@ def build_layers(self): class CU3Layer0(LayerTemplate0): """ - Layer template with CU3 blocks. - - This layer template consists of CU3 blocks repeated for the specified number of blocks. + Layer template with CU3 blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + This layer template consists of CU3 blocks repeated for the specified number of blocks. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Methods: - build_layers: Builds the CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - """ + Methods: + build_layers: Builds the CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -925,25 +945,24 @@ def build_layers(self): class CXRZSXLayer0(LayerTemplate0): """ - Layer template with CXRZSX blocks. + Layer template with CXRZSX blocks. - This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. + This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the CXRZSX layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ + Methods: + build_layers: Builds the CXRZSX layers for the template. + forward: Applies the quantum layer to the given quantum device. + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -977,24 +996,25 @@ def build_layers(self): class SethLayer0(LayerTemplate0): """ - Layer template with Seth blocks. + Layer template with Seth blocks. - This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. + This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1018,24 +1038,25 @@ def build_layers(self): class SethLayer1(LayerTemplate0): """ - Layer template with extended Seth blocks. + Layer template with extended Seth blocks. - This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. + This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the extended Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the extended Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1069,24 +1090,25 @@ def build_layers(self): class SethLayer2(LayerTemplate0): """ - Layer template with Seth blocks using Op2QFit32Layer. + Layer template with Seth blocks using Op2QFit32Layer. - This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. + This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Seth layers with Op2QFit32Layer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Seth layers with Op2QFit32Layer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1105,24 +1127,25 @@ def build_layers(self): class RZZLayer0(LayerTemplate0): """ - Layer template with RZZ blocks. + Layer template with RZZ blocks. - This layer template consists of RZZ blocks using the Op2QAllLayer. + This layer template consists of RZZ blocks using the Op2QAllLayer. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RZZ layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the RZZ layers with Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1141,24 +1164,25 @@ def build_layers(self): class BarrenLayer0(LayerTemplate0): """ - Layer template with Barren blocks. + Layer template with Barren blocks. - This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. + This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() layers_all.append( @@ -1189,24 +1213,25 @@ def build_layers(self): class FarhiLayer0(LayerTemplate0): """ - Layer template with Farhi blocks. + Layer template with Farhi blocks. + + This layer template consists of Farhi blocks using the Op2QAllLayer. - This layer template consists of Farhi blocks using the Op2QAllLayer. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Methods: + build_layers: Builds the Farhi layers with Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. - Methods: - build_layers: Builds the Farhi layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1235,24 +1260,25 @@ def build_layers(self): class MaxwellLayer0(LayerTemplate0): """ - Layer template with Maxwell blocks. + Layer template with Maxwell blocks. - This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. + This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1307,24 +1333,25 @@ def build_layers(self): class RYRYCXLayer0(LayerTemplate0): """ - Layer template with RYRYCX blocks. + Layer template with RYRYCX blocks. - This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. + This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. - forward: Applies the quantum layer to the given quantum device. + Methods: + build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1339,23 +1366,23 @@ def build_layers(self): class RYRYRYCXCXCXLayer0(LayerTemplate0): """ - Layer template with RYRYRYCXCXCX blocks. + Layer template with RYRYRYCXCXCX blocks. - This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. + This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. - """ + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -1371,24 +1398,25 @@ def build_layers(self): class RYRYRYLayer0(LayerTemplate0): """ - Layer template with RYRYRYCXCXCX blocks. + Layer template with RYRYRYCXCXCX blocks. - This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. + This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. - """ + """ + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1402,24 +1430,25 @@ def build_layers(self): class RYRYRYSWAPSWAPLayer0(LayerTemplate0): """ - Layer template with RYRYRYSWAPSWAP blocks. + Layer template with RYRYRYSWAPSWAP blocks. - This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. + This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. + Methods: + build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. - """ + """ + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -1434,23 +1463,23 @@ def build_layers(self): class SWAPSWAPLayer0(LayerTemplate0): """ - Layer template with SWAPSWAP blocks. + Layer template with SWAPSWAP blocks. - This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. + This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. + Methods: + build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. - """ + """ def build_layers(self): layers_all = tq.QuantumModuleList() @@ -1461,23 +1490,24 @@ def build_layers(self): class RXYZCXLayer0(LayerTemplate0): """ - Layer template with RXYZCX blocks. + Layer template with RXYZCX blocks. - This layer template consists of RXYZCX blocks using the RXYZCXLayer module. + This layer template consists of RXYZCX blocks using the RXYZCXLayer module. - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. - Methods: - build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. + Methods: + build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. + + """ - """ def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): diff --git a/torchquantum/layer/nlocal/efficient_su2.py b/torchquantum/layer/nlocal/efficient_su2.py index 4bd7cf27..e2c45b22 100644 --- a/torchquantum/layer/nlocal/efficient_su2.py +++ b/torchquantum/layer/nlocal/efficient_su2.py @@ -49,7 +49,7 @@ def __init__( ): # construct circuit with rotation layers of RY and RZ and entanglement with CX super().__init__( - n_wires = n_wires, + n_wires=n_wires, rotation_ops=[tq.RY, tq.RZ], entanglement_ops=[tq.CNOT], entanglement_layer=entanglement_layer, diff --git a/torchquantum/layer/nlocal/excitation_preserving.py b/torchquantum/layer/nlocal/excitation_preserving.py index f2e04742..b3ae3b45 100644 --- a/torchquantum/layer/nlocal/excitation_preserving.py +++ b/torchquantum/layer/nlocal/excitation_preserving.py @@ -49,7 +49,7 @@ def __init__( ): # construct circuit with rotation layers of RZ and entanglement with RXX and RYY super().__init__( - n_wires = n_wires, + n_wires=n_wires, rotation_ops=[tq.RZ], entanglement_ops=[tq.RXX, tq.RYY], entanglement_layer=entanglement_layer, From 5b63a97281dc79e69da324289c6ac0634dc9b7df Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Fri, 24 Nov 2023 20:47:43 -0500 Subject: [PATCH 054/106] [minor] fix README --- README.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/README.md b/README.md index d905eb03..eb10fa99 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,6 @@ MIT License - Chat @ Slack @@ -26,7 +25,6 @@ Website - Pypi From 19762fa763cb4ef01b5320c694f754459b7d9240 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 1 Dec 2023 20:46:17 -0500 Subject: [PATCH 055/106] reformatted hadamard for functionals --- torchquantum/functional/functionals.py | 350 +----------------------- torchquantum/functional/gate_wrapper.py | 259 ++++++++++++++++++ torchquantum/functional/hadamard.py | 118 ++++++++ 3 files changed, 382 insertions(+), 345 deletions(-) create mode 100644 torchquantum/functional/gate_wrapper.py create mode 100644 torchquantum/functional/hadamard.py diff --git a/torchquantum/functional/functionals.py b/torchquantum/functional/functionals.py index d459cdb8..6c2dc809 100644 --- a/torchquantum/functional/functionals.py +++ b/torchquantum/functional/functionals.py @@ -32,6 +32,9 @@ from torchpack.utils.logging import logger from torchquantum.util import normalize_statevector +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm +from .hadamard import hadamard, shadamard, HADAMARD_MATRIX, SHADAMARD_MATRIX + if TYPE_CHECKING: from torchquantum.device import QuantumDevice else: @@ -130,248 +133,6 @@ ] -def apply_unitary_einsum(state, mat, wires): - """Apply the unitary to the statevector using torch.einsum method. - - Args: - state (torch.Tensor): The statevector. - mat (torch.Tensor): The unitary matrix of the operation. - wires (int or List[int]): Which qubit the operation is applied to. - - Returns: - torch.Tensor: The new statevector. - - """ - device_wires = wires - - # minus one because of batch - total_wires = len(state.shape) - 1 - - if len(mat.shape) > 2: - is_batch_unitary = True - bsz = mat.shape[0] - shape_extension = [bsz] - # try: - # assert state.shape[0] == bsz - # except AssertionError as err: - # logger.exception(f"Batch size of Quantum Device must be the same" - # f" with that of gate unitary matrix") - # raise err - - else: - is_batch_unitary = False - shape_extension = [] - - mat = mat.view(shape_extension + [2] * len(device_wires) * 2) - - mat = mat.type(C_DTYPE).to(state.device) - - # Tensor indices of the quantum state - state_indices = ABC[:total_wires] - - # Indices of the quantum state affected by this operation - affected_indices = "".join(ABC_ARRAY[list(device_wires)].tolist()) - - # All affected indices will be summed over, so we need the same number - # of new indices - new_indices = ABC[total_wires : total_wires + len(device_wires)] - - # The new indices of the state are given by the old ones with the - # affected indices replaced by the new_indices - new_state_indices = functools.reduce( - lambda old_string, idx_pair: old_string.replace(idx_pair[0], idx_pair[1]), - zip(affected_indices, new_indices), - state_indices, - ) - - # try: - # cannot support too many qubits... - # assert ABC[-1] not in state_indices + new_state_indices \ - # + new_indices + affected_indices - # except AssertionError as err: - # logger.exception(f"Cannot support too many qubit.") - # raise err - - state_indices = ABC[-1] + state_indices - new_state_indices = ABC[-1] + new_state_indices - if is_batch_unitary: - new_indices = ABC[-1] + new_indices - - # We now put together the indices in the notation numpy einsum - # requires - einsum_indices = ( - f"{new_indices}{affected_indices}," f"{state_indices}->{new_state_indices}" - ) - - new_state = torch.einsum(einsum_indices, mat, state) - - return new_state - - -def apply_unitary_bmm(state, mat, wires): - """Apply the unitary to the statevector using torch.bmm method. - - Args: - state (torch.Tensor): The statevector. - mat (torch.Tensor): The unitary matrix of the operation. - wires (int or List[int]): Which qubit the operation is applied to. - - Returns: - torch.Tensor: The new statevector. - - """ - device_wires = wires - - # if len(mat.shape) > 2: - # bsz = mat.shape[0] - # try: - # assert state.shape[0] == bsz - # except AssertionError as err: - # logger.exception(f"Batch size of Quantum Device must be the same" - # f" with that of gate unitary matrix") - # raise err - mat = mat.type(C_DTYPE).to(state.device) - - devices_dims = [w + 1 for w in device_wires] - permute_to = list(range(state.dim())) - for d in sorted(devices_dims, reverse=True): - del permute_to[d] - permute_to = permute_to[:1] + devices_dims + permute_to[1:] - permute_back = list(np.argsort(permute_to)) - original_shape = state.shape - permuted = state.permute(permute_to).reshape([original_shape[0], mat.shape[-1], -1]) - - if len(mat.shape) > 2: - # both matrix and state are in batch mode - new_state = mat.bmm(permuted) - else: - # matrix no batch, state in batch mode - bsz = permuted.shape[0] - expand_shape = [bsz] + list(mat.shape) - new_state = mat.expand(expand_shape).bmm(permuted) - - new_state = new_state.view(original_shape).permute(permute_back) - - return new_state - - -def gate_wrapper( - name, - mat, - method, - q_device: QuantumDevice, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, -): - """Perform the phaseshift gate. - - Args: - name (str): The name of the operation. - mat (torch.Tensor): The unitary matrix of the gate. - method (str): 'bmm' or 'einsum' to compute matrix vector - multiplication. - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - if params is not None: - if not isinstance(params, torch.Tensor): - if name in ["qubitunitary", "qubitunitaryfast", "qubitunitarystrict"]: - # this is for qubitunitary gate - params = torch.tensor(params, dtype=C_DTYPE) - else: - # this is for directly inputting parameters as a number - params = torch.tensor(params, dtype=F_DTYPE) - - if name in ["qubitunitary", "qubitunitaryfast", "qubitunitarystrict"]: - params = params.unsqueeze(0) if params.dim() == 2 else params - else: - if params.dim() == 1: - params = params.unsqueeze(-1) - elif params.dim() == 0: - params = params.unsqueeze(-1).unsqueeze(-1) - # params = params.unsqueeze(-1) if params.dim() == 1 else params - wires = [wires] if isinstance(wires, int) else wires - - if q_device.record_op: - q_device.op_history.append( - { - "name": name, # type: ignore - "wires": np.array(wires).squeeze().tolist(), - "params": params.squeeze().detach().cpu().numpy().tolist() - if params is not None - else None, - "inverse": inverse, - "trainable": params.requires_grad if params is not None else False, - } - ) - - if static: - # in static mode, the function is not computed immediately, instead, - # the unitary of a module will be computed and then applied - parent_graph.add_func( - name=name, - wires=wires, - parent_graph=parent_graph, - params=params, - n_wires=n_wires, - inverse=inverse, - ) - else: - # in dynamic mode, the function is computed instantly - if isinstance(mat, Callable): - if n_wires is None or name in [ - "qubitunitary", - "qubitunitaryfast", - "qubitunitarystrict", - ]: - matrix = mat(params) - elif name in ["multicnot", "multixcnot", "qft"]: - # this is for gates that can be applied to arbitrary numbers of - # qubits but no params, such as multicnot - matrix = mat(n_wires) - elif name in ["multirz"]: - # this is for gates that can be applied to arbitrary numbers of - # qubits such as multirz - matrix = mat(params, n_wires) - else: - matrix = mat(params) - - else: - matrix = mat - - if inverse: - matrix = matrix.conj() - if matrix.dim() == 3: - matrix = matrix.permute(0, 2, 1) - else: - matrix = matrix.permute(1, 0) - assert np.log2(matrix.shape[-1]) == len(wires) - state = q_device.states - if method == "einsum": - q_device.states = apply_unitary_einsum(state, matrix, wires) - elif method == "bmm": - q_device.states = apply_unitary_bmm(state, matrix, wires) - - def reset(q_device: QuantumDevice, wires, inverse=False): # reset the target qubits to 0, non-unitary operation state = q_device.states @@ -1425,16 +1186,8 @@ def c3sx_matrix(): mat_dict = { - "hadamard": torch.tensor( - [[INV_SQRT2, INV_SQRT2], [INV_SQRT2, -INV_SQRT2]], dtype=C_DTYPE - ), - "shadamard": torch.tensor( - [ - [np.cos(np.pi / 8), -np.sin(np.pi / 8)], - [np.sin(np.pi / 8), np.cos(np.pi / 8)], - ], - dtype=C_DTYPE, - ), + "hadamard": HADAMARD_MATRIX, + "shadamard": SHADAMARD_MATRIX, "paulix": torch.tensor([[0, 1], [1, 0]], dtype=C_DTYPE), "pauliy": torch.tensor([[0, -1j], [1j, 0]], dtype=C_DTYPE), "pauliz": torch.tensor([[1, 0], [0, -1]], dtype=C_DTYPE), @@ -1613,99 +1366,6 @@ def c3sx_matrix(): } -def hadamard( - q_device: QuantumDevice, - wires: Union[List[int], int], - params: torch.Tensor = None, - n_wires: int = None, - static: bool = False, - parent_graph=None, - inverse: bool = False, - comp_method: str = "bmm", -): - """Perform the hadamard gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "hadamard" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def shadamard( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the shadamard gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "shadamard" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - def paulix( q_device, diff --git a/torchquantum/functional/gate_wrapper.py b/torchquantum/functional/gate_wrapper.py new file mode 100644 index 00000000..fa36153a --- /dev/null +++ b/torchquantum/functional/gate_wrapper.py @@ -0,0 +1,259 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def apply_unitary_einsum(state, mat, wires): + """Apply the unitary to the statevector using torch.einsum method. + + Args: + state (torch.Tensor): The statevector. + mat (torch.Tensor): The unitary matrix of the operation. + wires (int or List[int]): Which qubit the operation is applied to. + + Returns: + torch.Tensor: The new statevector. + + """ + device_wires = wires + + # minus one because of batch + total_wires = len(state.shape) - 1 + + if len(mat.shape) > 2: + is_batch_unitary = True + bsz = mat.shape[0] + shape_extension = [bsz] + # try: + # assert state.shape[0] == bsz + # except AssertionError as err: + # logger.exception(f"Batch size of Quantum Device must be the same" + # f" with that of gate unitary matrix") + # raise err + + else: + is_batch_unitary = False + shape_extension = [] + + mat = mat.view(shape_extension + [2] * len(device_wires) * 2) + + mat = mat.type(C_DTYPE).to(state.device) + + # Tensor indices of the quantum state + state_indices = ABC[:total_wires] + + # Indices of the quantum state affected by this operation + affected_indices = "".join(ABC_ARRAY[list(device_wires)].tolist()) + + # All affected indices will be summed over, so we need the same number + # of new indices + new_indices = ABC[total_wires : total_wires + len(device_wires)] + + # The new indices of the state are given by the old ones with the + # affected indices replaced by the new_indices + new_state_indices = functools.reduce( + lambda old_string, idx_pair: old_string.replace(idx_pair[0], idx_pair[1]), + zip(affected_indices, new_indices), + state_indices, + ) + + # try: + # cannot support too many qubits... + # assert ABC[-1] not in state_indices + new_state_indices \ + # + new_indices + affected_indices + # except AssertionError as err: + # logger.exception(f"Cannot support too many qubit.") + # raise err + + state_indices = ABC[-1] + state_indices + new_state_indices = ABC[-1] + new_state_indices + if is_batch_unitary: + new_indices = ABC[-1] + new_indices + + # We now put together the indices in the notation numpy einsum + # requires + einsum_indices = ( + f"{new_indices}{affected_indices}," f"{state_indices}->{new_state_indices}" + ) + + new_state = torch.einsum(einsum_indices, mat, state) + + return new_state + + +def apply_unitary_bmm(state, mat, wires): + """Apply the unitary to the statevector using torch.bmm method. + + Args: + state (torch.Tensor): The statevector. + mat (torch.Tensor): The unitary matrix of the operation. + wires (int or List[int]): Which qubit the operation is applied to. + + Returns: + torch.Tensor: The new statevector. + + """ + device_wires = wires + + # if len(mat.shape) > 2: + # bsz = mat.shape[0] + # try: + # assert state.shape[0] == bsz + # except AssertionError as err: + # logger.exception(f"Batch size of Quantum Device must be the same" + # f" with that of gate unitary matrix") + # raise err + mat = mat.type(C_DTYPE).to(state.device) + + devices_dims = [w + 1 for w in device_wires] + permute_to = list(range(state.dim())) + for d in sorted(devices_dims, reverse=True): + del permute_to[d] + permute_to = permute_to[:1] + devices_dims + permute_to[1:] + permute_back = list(np.argsort(permute_to)) + original_shape = state.shape + permuted = state.permute(permute_to).reshape([original_shape[0], mat.shape[-1], -1]) + + if len(mat.shape) > 2: + # both matrix and state are in batch mode + new_state = mat.bmm(permuted) + else: + # matrix no batch, state in batch mode + bsz = permuted.shape[0] + expand_shape = [bsz] + list(mat.shape) + new_state = mat.expand(expand_shape).bmm(permuted) + + new_state = new_state.view(original_shape).permute(permute_back) + + return new_state + + + +def gate_wrapper( + name, + mat, + method, + q_device: QuantumDevice, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, +): + """Perform the phaseshift gate. + + Args: + name (str): The name of the operation. + mat (torch.Tensor): The unitary matrix of the gate. + method (str): 'bmm' or 'einsum' to compute matrix vector + multiplication. + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + if params is not None: + if not isinstance(params, torch.Tensor): + if name in ["qubitunitary", "qubitunitaryfast", "qubitunitarystrict"]: + # this is for qubitunitary gate + params = torch.tensor(params, dtype=C_DTYPE) + else: + # this is for directly inputting parameters as a number + params = torch.tensor(params, dtype=F_DTYPE) + + if name in ["qubitunitary", "qubitunitaryfast", "qubitunitarystrict"]: + params = params.unsqueeze(0) if params.dim() == 2 else params + else: + if params.dim() == 1: + params = params.unsqueeze(-1) + elif params.dim() == 0: + params = params.unsqueeze(-1).unsqueeze(-1) + # params = params.unsqueeze(-1) if params.dim() == 1 else params + wires = [wires] if isinstance(wires, int) else wires + + if q_device.record_op: + q_device.op_history.append( + { + "name": name, # type: ignore + "wires": np.array(wires).squeeze().tolist(), + "params": params.squeeze().detach().cpu().numpy().tolist() + if params is not None + else None, + "inverse": inverse, + "trainable": params.requires_grad if params is not None else False, + } + ) + + if static: + # in static mode, the function is not computed immediately, instead, + # the unitary of a module will be computed and then applied + parent_graph.add_func( + name=name, + wires=wires, + parent_graph=parent_graph, + params=params, + n_wires=n_wires, + inverse=inverse, + ) + else: + # in dynamic mode, the function is computed instantly + if isinstance(mat, Callable): + if n_wires is None or name in [ + "qubitunitary", + "qubitunitaryfast", + "qubitunitarystrict", + ]: + matrix = mat(params) + elif name in ["multicnot", "multixcnot", "qft"]: + # this is for gates that can be applied to arbitrary numbers of + # qubits but no params, such as multicnot + matrix = mat(n_wires) + elif name in ["multirz"]: + # this is for gates that can be applied to arbitrary numbers of + # qubits such as multirz + matrix = mat(params, n_wires) + else: + matrix = mat(params) + + else: + matrix = mat + + if inverse: + matrix = matrix.conj() + if matrix.dim() == 3: + matrix = matrix.permute(0, 2, 1) + else: + matrix = matrix.permute(1, 0) + assert np.log2(matrix.shape[-1]) == len(wires) + state = q_device.states + if method == "einsum": + q_device.states = apply_unitary_einsum(state, matrix, wires) + elif method == "bmm": + q_device.states = apply_unitary_bmm(state, matrix, wires) + + diff --git a/torchquantum/functional/hadamard.py b/torchquantum/functional/hadamard.py new file mode 100644 index 00000000..1efdb0ff --- /dev/null +++ b/torchquantum/functional/hadamard.py @@ -0,0 +1,118 @@ +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +import torch +import numpy as np +from .gate_wrapper import gate_wrapper + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + +HADAMARD_MATRIX = torch.tensor( + [[INV_SQRT2, INV_SQRT2], [INV_SQRT2, -INV_SQRT2]], dtype=C_DTYPE +) + +SHADAMARD_MATRIX = torch.tensor( + [ + [np.cos(np.pi / 8), -np.sin(np.pi / 8)], + [np.sin(np.pi / 8), np.cos(np.pi / 8)], + ], + dtype=C_DTYPE, +) + +def hadamard( + q_device: QuantumDevice, + wires: Union[List[int], int], + params: torch.Tensor = None, + n_wires: int = None, + static: bool = False, + parent_graph=None, + inverse: bool = False, + comp_method: str = "bmm", +): + """Perform the hadamard gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "hadamard" + mat = HADAMARD_MATRIX + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def shadamard( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the shadamard gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "shadamard" + mat = mat_dict[name] + mat = SHADAMARD_MATRIX + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + From 15bfb8c67a195f57a4283fe00b55c2f9a2ef4f3d Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 1 Dec 2023 21:04:31 -0500 Subject: [PATCH 056/106] moved the test locations --- .github/workflows/example_tests.yaml | 49 ------------------------- .github/workflows/functional_tests.yaml | 19 +++++++++- 2 files changed, 18 insertions(+), 50 deletions(-) delete mode 100644 .github/workflows/example_tests.yaml diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml deleted file mode 100644 index 8d0f1df6..00000000 --- a/.github/workflows/example_tests.yaml +++ /dev/null @@ -1,49 +0,0 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - -name: Python package - -on: - push: - pull_request: - -jobs: - build: - - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] - - steps: - - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Test Examples - run: | - python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 - python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 - python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 - python3 examples/train_state_prep/train_state_prep.py --epochs 1 - python3 examples/superdense_coding/superdense_coding_torchquantum.py - python3 examples/regression/run_regression.py --epochs 1 - python3 examples/param_shift_onchip_training/param_shift.py - python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 - python3 examples/hadamard_grad/circ.py - python3 examples/encoder_examples/encoder_8x2ry.py - python3 examples/converter_tq_qiskit/convert.py - python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 - python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 - python3 examples/PauliSumOp/pauli_sum_op.py - python3 examples/regression/new_run_regression.py --epochs 1 - python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 - python3 examples/grover/grover_example_sudoku.py - python3 examples/param_shift_onchip_training/param_shift.py diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 9b26ef72..7b9dfb50 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -41,4 +41,21 @@ jobs: pip install --editable . - name: Test Examples run: | - python3 examples/qubit_rotation/qubit_rotation.py + python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 + python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 + python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 + python3 examples/train_state_prep/train_state_prep.py --epochs 1 + python3 examples/superdense_coding/superdense_coding_torchquantum.py + python3 examples/regression/run_regression.py --epochs 1 + python3 examples/param_shift_onchip_training/param_shift.py + python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 + python3 examples/hadamard_grad/circ.py + python3 examples/encoder_examples/encoder_8x2ry.py + python3 examples/converter_tq_qiskit/convert.py + python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 + python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 + python3 examples/PauliSumOp/pauli_sum_op.py + python3 examples/regression/new_run_regression.py --epochs 1 + python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 + python3 examples/grover/grover_example_sudoku.py + python3 examples/param_shift_onchip_training/param_shift.py From e22c64e7eee98198b8fc5c6482b622927cf4b6a9 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 1 Dec 2023 21:38:49 -0500 Subject: [PATCH 057/106] [minor] removed unnecessary tests and added tests for python 3.12 --- .github/workflows/example_tests.yaml | 49 ------------------------- .github/workflows/functional_tests.yaml | 2 +- 2 files changed, 1 insertion(+), 50 deletions(-) delete mode 100644 .github/workflows/example_tests.yaml diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml deleted file mode 100644 index 8d0f1df6..00000000 --- a/.github/workflows/example_tests.yaml +++ /dev/null @@ -1,49 +0,0 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - -name: Python package - -on: - push: - pull_request: - -jobs: - build: - - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] - - steps: - - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Test Examples - run: | - python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 - python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 - python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 - python3 examples/train_state_prep/train_state_prep.py --epochs 1 - python3 examples/superdense_coding/superdense_coding_torchquantum.py - python3 examples/regression/run_regression.py --epochs 1 - python3 examples/param_shift_onchip_training/param_shift.py - python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 - python3 examples/hadamard_grad/circ.py - python3 examples/encoder_examples/encoder_8x2ry.py - python3 examples/converter_tq_qiskit/convert.py - python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 - python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 - python3 examples/PauliSumOp/pauli_sum_op.py - python3 examples/regression/new_run_regression.py --epochs 1 - python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 - python3 examples/grover/grover_example_sudoku.py - python3 examples/param_shift_onchip_training/param_shift.py diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 7b9dfb50..334d32cf 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -14,7 +14,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] + python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v3 From 56f29adf59bff2e3b015a23db56753a5e0947cf4 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 22 Dec 2023 22:00:25 -0600 Subject: [PATCH 058/106] minor reformatting of the layers --- test/layers/test_rotgate.py | 73 +++++++++++++++++++------------------ 1 file changed, 37 insertions(+), 36 deletions(-) diff --git a/test/layers/test_rotgate.py b/test/layers/test_rotgate.py index c69d5569..30f24b8a 100644 --- a/test/layers/test_rotgate.py +++ b/test/layers/test_rotgate.py @@ -17,39 +17,40 @@ {"qiskit": GRZ, "tq": tq.layer.GlobalRZ, "params": 1}, ] -ITERATIONS = 10 - -# test each pair -for pair in all_pairs: - # test 2-5 wires - for num_wires in range(2, 5): - # try multiple random parameters - for _ in range(ITERATIONS): - # generate random parameters - params = [ - np.random.uniform(-2 * np.pi, 2 * np.pi) for _ in range(pair["params"]) - ] - - # create the qiskit circuit - qiskit_circuit = pair["qiskit"](num_wires, *params) - - # get the unitary from qiskit - backend = Aer.get_backend("unitary_simulator") - result = execute(qiskit_circuit, backend).result() - unitary_qiskit = result.get_unitary(qiskit_circuit) - - # create tq circuit - qdev = tq.QuantumDevice(num_wires) - tq_circuit = pair["tq"](num_wires, *params) - tq_circuit(qdev) - - # get the unitary from tq - unitary_tq = tq_circuit.get_unitary(qdev) - unitary_tq = switch_little_big_endian_matrix(unitary_tq.data.numpy()) - - # phase? - phase = find_global_phase(unitary_tq, unitary_qiskit, 1e-4) - - assert np.allclose( - unitary_tq * phase, unitary_qiskit, atol=1e-6 - ), f"{pair} not equal with {params=}!" +ITERATIONS = 2 + +def test_rotgates(): + # test each pair + for pair in all_pairs: + # test 2-5 wires + for num_wires in range(2, 5): + # try multiple random parameters + for _ in range(ITERATIONS): + # generate random parameters + params = [ + np.random.uniform(-2 * np.pi, 2 * np.pi) for _ in range(pair["params"]) + ] + + # create the qiskit circuit + qiskit_circuit = pair["qiskit"](num_wires, *params) + + # get the unitary from qiskit + backend = Aer.get_backend("unitary_simulator") + result = execute(qiskit_circuit, backend).result() + unitary_qiskit = result.get_unitary(qiskit_circuit) + + # create tq circuit + qdev = tq.QuantumDevice(num_wires) + tq_circuit = pair["tq"](num_wires, *params) + tq_circuit(qdev) + + # get the unitary from tq + unitary_tq = tq_circuit.get_unitary(qdev) + unitary_tq = switch_little_big_endian_matrix(unitary_tq.data.numpy()) + + # phase? + phase = find_global_phase(unitary_tq, unitary_qiskit, 1e-4) + + assert np.allclose( + unitary_tq * phase, unitary_qiskit, atol=1e-6 + ), f"{pair} not equal with {params=}!" From 679f7972f6226a6ffcc47e70000bd1d0805235b5 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 22 Dec 2023 22:01:22 -0600 Subject: [PATCH 059/106] light general gates reformatting --- torchquantum/layer/general/__init__.py | 1 + torchquantum/layer/{general.py => general/globalr.py} | 0 2 files changed, 1 insertion(+) create mode 100644 torchquantum/layer/general/__init__.py rename torchquantum/layer/{general.py => general/globalr.py} (100%) diff --git a/torchquantum/layer/general/__init__.py b/torchquantum/layer/general/__init__.py new file mode 100644 index 00000000..bc35adde --- /dev/null +++ b/torchquantum/layer/general/__init__.py @@ -0,0 +1 @@ +from .globalr import GlobalR, GlobalRX, GlobalRY, GlobalRZ diff --git a/torchquantum/layer/general.py b/torchquantum/layer/general/globalr.py similarity index 100% rename from torchquantum/layer/general.py rename to torchquantum/layer/general/globalr.py From af575f4852f7ae85eacb66cdfbd6072794eeeb0d Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 23 Dec 2023 14:58:53 -0600 Subject: [PATCH 060/106] separated entanglement into separate folder and started separating the rest of the gates --- torchquantum/layer/layers/__init__.py | 4 + torchquantum/layer/layers/layers.py | 1002 ++++++++++++++++++ torchquantum/layer/layers/module_from_ops.py | 66 ++ torchquantum/layer/layers/op_all.py | 191 ++++ torchquantum/layer/layers/random_layers.py | 298 ++++++ 5 files changed, 1561 insertions(+) create mode 100644 torchquantum/layer/layers/__init__.py create mode 100644 torchquantum/layer/layers/layers.py create mode 100644 torchquantum/layer/layers/module_from_ops.py create mode 100644 torchquantum/layer/layers/op_all.py create mode 100644 torchquantum/layer/layers/random_layers.py diff --git a/torchquantum/layer/layers/__init__.py b/torchquantum/layer/layers/__init__.py new file mode 100644 index 00000000..25ebfa78 --- /dev/null +++ b/torchquantum/layer/layers/__init__.py @@ -0,0 +1,4 @@ +from .module_from_ops import QuantumModuleFromOps +from .op_all import TrainableOpAll, ClassicalInOpAll, FixedOpAll, TwoQAll +from .random_layers import RandomLayer, RandomLayerAllTypes, RandomOp1All +from .layers import * diff --git a/torchquantum/layer/layers/layers.py b/torchquantum/layer/layers/layers.py new file mode 100644 index 00000000..26433b66 --- /dev/null +++ b/torchquantum/layer/layers/layers.py @@ -0,0 +1,1002 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger +from ..entanglement.op2_layer import Op2QAllLayer + +__all__ = [ + "LayerTemplate0", + "Op1QAllLayer", + "layer_name_dict", + "CXLayer", + "CXCXCXLayer", + "SWAPSWAPLayer", + "RXYZCXLayer0", + "QFTLayer", +] + + +class SimpleQLayer(tq.QuantumModule): + """ + Simple quantum layer consisting of three parameterized gates applied to specific wires. + + This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + self.gate1 = tq.RX(has_params=True, trainable=True) + self.gate2 = tq.RY(has_params=True, trainable=True) + self.gate3 = tq.RZ(has_params=True, trainable=True) + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.x(q_dev, wires=0, static=self.static_mode, parent_graph=self.graph) + self.gate1(q_dev, wires=1) + self.gate2(q_dev, wires=1) + self.gate3(q_dev, wires=1) + tqf.x(q_dev, wires=2, static=self.static_mode, parent_graph=self.graph) + + +class CXLayer(tq.QuantumModule): + """ + Quantum layer with a controlled-X (CX) gate applied to two specified wires. + + This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) + + +class CXCXCXLayer(tq.QuantumModule): + """ + Quantum layer with a sequence of CX gates applied to three specified wires. + + This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) + tqf.cnot(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) + tqf.cnot(q_dev, wires=[2, 0], static=self.static_mode, parent_graph=self.graph) + + +class SWAPSWAPLayer(tq.QuantumModule): + """ + Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. + + This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.swap(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) + tqf.swap(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) + + +class Op1QAllLayer(tq.QuantumModule): + """ + Quantum layer applying the same single-qubit operation to all wires. + + This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. + + Args: + op (tq.Operator): Single-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + + """ + + def __init__(self, op, n_wires: int, has_params=False, trainable=False): + super().__init__() + self.n_wires = n_wires + self.op = op + self.ops_all = tq.QuantumModuleList() + for k in range(n_wires): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + @tq.static_support + def forward(self, q_device): + for k in range(self.n_wires): + self.ops_all[k](q_device, wires=k) + + +class LayerTemplate0(tq.QuantumModule): + """ + A template for a custom quantum layer. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. (Optional) + n_layers_per_block (int): The number of layers per block. (Optional) + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Abstract method to build the layers of the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def __init__(self, arch: dict = None): + super().__init__() + self.n_wires = arch["n_wires"] + self.arch = arch + + self.n_blocks = arch.get("n_blocks", None) + self.n_layers_per_block = arch.get("n_layers_per_block", None) + + self.layers_all = self.build_layers() + + def build_layers(self): + raise NotImplementedError + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + self.q_device = q_device + for k in range(len(self.layers_all)): + self.layers_all[k](q_device) + + +class U3CU3Layer0(LayerTemplate0): + """ + Layer template with U3 and CU3 blocks. + + This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the U3 and CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.U3, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer( + op=tq.CU3, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class CU3Layer0(LayerTemplate0): + """ + Layer template with CU3 blocks. + + This layer template consists of CU3 blocks repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.CU3, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=False, + ) + ) + return layers_all + + +class CXRZSXLayer0(LayerTemplate0): + """ + Layer template with CXRZSX blocks. + + This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the CXRZSX layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + + layers_all.append( + Op1QAllLayer( + op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=False) + ) + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.SX, n_wires=self.n_wires, has_params=False, trainable=False + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + return layers_all + + +class SethLayer0(LayerTemplate0): + """ + Layer template with Seth blocks. + + This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + return layers_all + + +class SethLayer1(LayerTemplate0): + """ + Layer template with extended Seth blocks. + + This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the extended Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class SethLayer2(LayerTemplate0): + """ + Layer template with Seth blocks using Op2QFit32Layer. + + This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Seth layers with Op2QFit32Layer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QFit32Layer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class RZZLayer0(LayerTemplate0): + """ + Layer template with RZZ blocks. + + This layer template consists of RZZ blocks using the Op2QAllLayer. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RZZ layers with Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class BarrenLayer0(LayerTemplate0): + """ + Layer template with Barren blocks. + + This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + layers_all.append( + Op1QAllLayer( + op=tq.SHadamard, + n_wires=self.n_wires, + ) + ) + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(Op2QAllLayer(op=tq.CZ, n_wires=self.n_wires, jump=1)) + return layers_all + + +class FarhiLayer0(LayerTemplate0): + """ + Layer template with Farhi blocks. + + This layer template consists of Farhi blocks using the Op2QAllLayer. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Farhi layers with Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.RZX, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + layers_all.append( + Op2QAllLayer( + op=tq.RXX, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class MaxwellLayer0(LayerTemplate0): + """ + Layer template with Maxwell blocks. + + This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(Op1QAllLayer(op=tq.S, n_wires=self.n_wires)) + layers_all.append( + Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) + ) + + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(Op1QAllLayer(op=tq.T, n_wires=self.n_wires)) + layers_all.append( + Op2QAllLayer(op=tq.SWAP, n_wires=self.n_wires, jump=1, circular=True) + ) + + layers_all.append( + Op1QAllLayer( + op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(Op1QAllLayer(op=tq.Hadamard, n_wires=self.n_wires)) + layers_all.append( + Op2QAllLayer(op=tq.SSWAP, n_wires=self.n_wires, jump=1, circular=True) + ) + + layers_all.append( + Op1QAllLayer( + op=tq.U1, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer( + op=tq.CU3, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + + return layers_all + + +class RYRYCXLayer0(LayerTemplate0): + """ + Layer template with RYRYCX blocks. + + This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(CXLayer(n_wires=self.n_wires)) + return layers_all + + +class RYRYRYCXCXCXLayer0(LayerTemplate0): + """ + Layer template with RYRYRYCXCXCX blocks. + + This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(CXCXCXLayer(n_wires=self.n_wires)) + return layers_all + + +class RYRYRYLayer0(LayerTemplate0): + """ + Layer template with RYRYRYCXCXCX blocks. + + This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. + + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + return layers_all + + +class RYRYRYSWAPSWAPLayer0(LayerTemplate0): + """ + Layer template with RYRYRYSWAPSWAP blocks. + + This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. + + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) + return layers_all + + +class SWAPSWAPLayer0(LayerTemplate0): + """ + Layer template with SWAPSWAP blocks. + + This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) + return layers_all + + +class RXYZCXLayer0(LayerTemplate0): + """ + Layer template with RXYZCX blocks. + + This layer template consists of RXYZCX blocks using the RXYZCXLayer module. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. + + """ + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) + ) + return layers_all + + +class QFTLayer(tq.QuantumModule): + def __init__( + self, + n_wires: int = None, + wires: Iterable = None, + do_swaps: bool = True, + inverse: bool = False, + ): + """ + Constructs a Quantum Fourier Transform (QFT) layer + + Args: + n_wires (int): Number of wires for the QFT as an integer + wires (Iterable): Wires to perform the QFT as an Iterable + do_swaps (bool): Whether or not to add the final swaps in a boolean format + inverse (bool): Whether to create an inverse QFT layer in a boolean format + """ + super().__init__() + + assert n_wires is not None or wires is not None + + if n_wires is None: + self.n_wires = len(wires) + + if wires is None: + wires = range(n_wires) + + self.n_wires = n_wires + self.wires = wires + self.do_swaps = do_swaps + + if inverse: + self.gates_all = self.build_inverse_circuit() + else: + self.gates_all = self.build_circuit() + + def build_circuit(self): + """Construct a QFT circuit.""" + + operation_list = [] + + # add the H and CU1 gates + for top_wire in range(self.n_wires): + operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) + for wire in range(top_wire + 1, self.n_wires): + lam = torch.pi / (2 ** (wire - top_wire)) + operation_list.append( + { + "name": "cu1", + "params": lam, + "wires": [self.wires[wire], self.wires[top_wire]], + } + ) + + # add swaps if specified + if self.do_swaps: + for wire in range(self.n_wires // 2): + operation_list.append( + { + "name": "swap", + "wires": [ + self.wires[wire], + self.wires[self.n_wires - wire - 1], + ], + } + ) + + return tq.QuantumModule.from_op_history(operation_list) + + def build_inverse_circuit(self): + """Construct the inverse of a QFT circuit.""" + + operation_list = [] + + # add swaps if specified + if self.do_swaps: + for wire in range(self.n_wires // 2): + operation_list.append( + { + "name": "swap", + "wires": [ + self.wires[wire], + self.wires[self.n_wires - wire - 1], + ], + } + ) + + # add the CU1 and H gates + for top_wire in range(self.n_wires)[::-1]: + for wire in range(top_wire + 1, self.n_wires)[::-1]: + lam = -torch.pi / (2 ** (wire - top_wire)) + operation_list.append( + { + "name": "cu1", + "params": lam, + "wires": [self.wires[wire], self.wires[top_wire]], + } + ) + operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) + + return tq.QuantumModule.from_op_history(operation_list) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + self.gates_all(q_device) + + +layer_name_dict = { + "u3cu3_0": U3CU3Layer0, + "cu3_0": CU3Layer0, + "cxrzsx_0": CXRZSXLayer0, + "seth_0": SethLayer0, + "seth_1": SethLayer1, + "seth_2": SethLayer2, + "rzz_0": RZZLayer0, + "barren_0": BarrenLayer0, + "farhi_0": FarhiLayer0, + "maxwell_0": MaxwellLayer0, + "ryrycx": RYRYCXLayer0, + "ryryrycxcxcx": RYRYRYCXCXCXLayer0, + "ryryry": RYRYRYLayer0, + "swapswap": SWAPSWAPLayer0, + "ryryryswapswap": RYRYRYSWAPSWAPLayer0, + "rxyzcx_0": RXYZCXLayer0, +} diff --git a/torchquantum/layer/layers/module_from_ops.py b/torchquantum/layer/layers/module_from_ops.py new file mode 100644 index 00000000..f5aea5e0 --- /dev/null +++ b/torchquantum/layer/layers/module_from_ops.py @@ -0,0 +1,66 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +__all__ = [ + "QuantumModuleFromOps", +] + + +class QuantumModuleFromOps(tq.QuantumModule): + """Initializes a QuantumModuleFromOps instance. + + Args: + ops (List[tq.Operation]): List of quantum operations. + + """ + + def __init__(self, ops): + super().__init__() + self.ops = tq.QuantumModuleList(ops) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + """Performs the forward pass of the quantum module. + + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. + + Returns: + None + + """ + self.q_device = q_device + for op in self.ops: + op(q_device) diff --git a/torchquantum/layer/layers/op_all.py b/torchquantum/layer/layers/op_all.py new file mode 100644 index 00000000..5b813907 --- /dev/null +++ b/torchquantum/layer/layers/op_all.py @@ -0,0 +1,191 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +__all__ = [ + "TrainableOpAll", + "ClassicalInOpAll", + "FixedOpAll", + "TwoQAll", + "Op1QAllLayer", +] + + +class TrainableOpAll(tq.QuantumModule): + """Rotation rx on all qubits + The rotation angle is a parameter of each rotation gate + One potential optimization is to compute the unitary of all gates + together. + """ + + def __init__(self, n_gate: int, op: tq.Operation): + super().__init__() + self.n_gate = n_gate + self.gate_all = nn.ModuleList() + for k in range(self.n_gate): + self.gate_all.append(op(has_params=True, trainable=True)) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + # rx on all wires, assert the number of gate is the same as the number + # of wires in the device. + assert self.n_gate == q_device.n_wires, ( + f"Number of rx gates ({self.n_gate}) is different from number " + f"of wires ({q_device.n_wires})!" + ) + + for k in range(self.n_gate): + self.gate_all[k](q_device, wires=k) + + +class ClassicalInOpAll(tq.QuantumModule): + """ + Quantum module that applies the same quantum operation to all wires of a quantum device, + where the parameters of the operation are obtained from a classical input. + + Args: + n_gate (int): Number of gates. + op (tq.Operator): Quantum operation to be applied. + + Attributes: + n_gate (int): Number of gates. + gate_all (nn.ModuleList): List of quantum operations. + + """ + + def __init__(self, n_gate: int, op: tq.Operator): + super().__init__() + self.n_gate = n_gate + self.gate_all = nn.ModuleList() + for k in range(self.n_gate): + self.gate_all.append(op()) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice, x): + """ + Performs the forward pass of the classical input quantum operation module. + + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. + x (torch.Tensor): Classical input of shape (batch_size, n_gate). + + Returns: + None + + Raises: + AssertionError: If the number of gates is different from the number of wires in the device. + + """ + # rx on all wires, assert the number of gate is the same as the number + # of wires in the device. + assert self.n_gate == q_device.n_wires, ( + f"Number of rx gates ({self.n_gate}) is different from number " + f"of wires ({q_device.n_wires})!" + ) + + for k in range(self.n_gate): + self.gate_all[k](q_device, wires=k, params=x[:, k]) + + +class FixedOpAll(tq.QuantumModule): + """ + Quantum module that applies the same fixed quantum operation to all wires of a quantum device. + + Args: + n_gate (int): Number of gates. + op (tq.Operator): Quantum operation to be applied. + + Attributes: + n_gate (int): Number of gates. + gate_all (nn.ModuleList): List of quantum operations. + + """ + + def __init__(self, n_gate: int, op: tq.Operator): + super().__init__() + self.n_gate = n_gate + self.gate_all = nn.ModuleList() + for k in range(self.n_gate): + self.gate_all.append(op()) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + """ + Performs the forward pass of the fixed quantum operation module. + + Args: + q_device (tq.QuantumDevice): Quantum device to apply the operations on. + + Returns: + None + + Raises: + AssertionError: If the number of gates is different from the number of wires in the device. + + """ + # rx on all wires, assert the number of gate is the same as the number + # of wires in the device. + assert self.n_gate == q_device.n_wires, ( + f"Number of rx gates ({self.n_gate}) is different from number " + f"of wires ({q_device.n_wires})!" + ) + + for k in range(self.n_gate): + self.gate_all[k](q_device, wires=k) + + +class TwoQAll(tq.QuantumModule): + """ + Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. + + Args: + n_gate (int): Number of adjacent pairs of wires. + op (tq.Operator): Two-qubit quantum operation to be applied. + + Attributes: + n_gate (int): Number of adjacent pairs of wires. + op (tq.Operator): Two-qubit quantum operation. + + """ + + def __init__(self, n_gate: int, op: tq.Operator): + super().__init__() + self.n_gate = n_gate + self.op = op() + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + for k in range(self.n_gate - 1): + self.op(q_device, wires=[k, k + 1]) + self.op(q_device, wires=[self.n_gate - 1, 0]) diff --git a/torchquantum/layer/layers/random_layers.py b/torchquantum/layer/layers/random_layers.py new file mode 100644 index 00000000..1ca55414 --- /dev/null +++ b/torchquantum/layer/layers/random_layers.py @@ -0,0 +1,298 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +__all__ = [ + "RandomLayer", + "RandomLayerAllTypes", + "RandomOp1All", +] + + +class RandomOp1All(tq.QuantumModule): + def __init__( + self, + n_wires: int, + op_types=(tq.RX, tq.RY, tq.RZ), + op_ratios=None, + has_params=True, + trainable=True, + seed=None, + ): + """Layer adding a random gate to all wires + + Params: + n_wires (int): number of wires/gates in integer format + op_types (Iterable): single-wire gates to select from in iterable format + op_ratios (Iterable): probabilities to select each gate option in iterable format + seed (int): random seed in integer format + """ + super().__init__() + self.n_wires = n_wires + self.op_types = op_types + self.op_ratios = op_ratios + self.seed = seed + self.gate_all = nn.ModuleList() + + if seed is not None: + np.random.seed(seed) + + for k in range(self.n_wires): + op = np.random.choice(self.op_types, p=self.op_ratios) + self.gate_all.append(op(has_params=has_params, trainable=trainable)) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + for k in range(self.n_wires): + self.gate_all[k](q_device, wires=k) + + +class RandomLayer(tq.QuantumModule): + """ + Quantum module that represents a random layer of quantum operations applied to specified wires. + + Args: + wires (int or Iterable[int]): Indices of the wires the operations are applied to. + n_ops (int): Number of random operations in the layer. + n_params (int): Number of parameters for each random operation. + op_ratios (list or float): Ratios determining the relative frequencies of different operation types. + op_types (tuple or tq.Operator): Types of random operations to be included in the layer. + seed (int): Seed for random number generation. + qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. + + Attributes: + n_ops (int): Number of random operations in the layer. + n_params (int): Number of parameters for each random operation. + wires (list): Indices of the wires the operations are applied to. + n_wires (int): Number of wires. + op_types (list): Types of random operations included in the layer. + op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. + seed (int): Seed for random number generation. + op_list (tq.QuantumModuleList): List of random operations in the layer. + + """ + + def __init__( + self, + wires, + n_ops=None, + n_params=None, + op_ratios=None, + op_types=(tq.RX, tq.RY, tq.RZ, tq.CNOT), + seed=None, + qiskit_compatible=False, + ): + super().__init__() + self.n_ops = n_ops + self.n_params = n_params + assert n_params is not None or n_ops is not None + self.wires = wires if isinstance(wires, Iterable) else [wires] + self.n_wires = len(wires) + + op_types = op_types if isinstance(op_types, Iterable) else [op_types] + if op_ratios is None: + op_ratios = [1] * len(op_types) + else: + op_ratios = op_ratios if isinstance(op_ratios, Iterable) else [op_ratios] + op_types_valid = [] + op_ratios_valid = [] + + if qiskit_compatible: + for op_type, op_ratio in zip(op_types, op_ratios): + if op_type().name.lower() in QISKIT_INCOMPATIBLE_FUNC_NAMES: + logger.warning( + f"Remove {op_type} from op_types to make " + f"the layer qiskit-compatible." + ) + else: + op_types_valid.append(op_type) + op_ratios_valid.append(op_ratio) + else: + op_types_valid = op_types + op_ratios_valid = op_ratios + + self.op_types = op_types_valid + self.op_ratios = np.array(op_ratios_valid) / sum(op_ratios_valid) + + self.seed = seed + self.op_list = tq.QuantumModuleList() + if seed is not None: + np.random.seed(seed) + self.build_random_layer() + + def rebuild_random_layer_from_op_list(self, n_ops_in, wires_in, op_list_in): + """ + Rebuilds a random layer from the given operation list. + This method is used for loading a random layer from a checkpoint. + + Args: + n_ops_in (int): Number of operations in the layer. + wires_in (list): Indices of the wires the operations are applied to. + op_list_in (list): List of operations in the layer. + + """ + + self.n_ops = n_ops_in + self.wires = wires_in + self.op_list = tq.QuantumModuleList() + for op_in in op_list_in: + op = tq.op_name_dict[op_in.name.lower()]( + has_params=op_in.has_params, + trainable=op_in.trainable, + wires=op_in.wires, + n_wires=op_in.n_wires, + ) + self.op_list.append(op) + + def build_random_layer(self): + op_cnt = 0 + param_cnt = 0 + while True: + op = np.random.choice(self.op_types, p=self.op_ratios) + n_op_wires = op.num_wires + if n_op_wires > self.n_wires: + continue + if n_op_wires == -1: + is_AnyWire = True + n_op_wires = self.n_wires + else: + is_AnyWire = False + + op_wires = list( + np.random.choice(self.wires, size=n_op_wires, replace=False) + ) + if is_AnyWire: + if op().name in ["MultiRZ"]: + operation = op( + has_params=True, + trainable=True, + n_wires=n_op_wires, + wires=op_wires, + ) + else: + operation = op(n_wires=n_op_wires, wires=op_wires) + elif op().name in tq.operator.parameterized_ops: + operation = op(has_params=True, trainable=True, wires=op_wires) + else: + operation = op(wires=op_wires) + self.op_list.append(operation) + op_cnt += 1 + param_cnt += op.num_params + + if self.n_ops is not None and op_cnt == self.n_ops: + break + elif self.n_ops is None and self.n_params is not None: + if param_cnt == self.n_params: + break + elif param_cnt > self.n_params: + """ + the last operation has too many params and exceed the + constraint, so need to remove it and sample another + """ + op_cnt -= 1 + param_cnt -= op.num_params + del self.op_list[-1] + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + for op in self.op_list: + op(q_device) + + +class RandomLayerAllTypes(RandomLayer): + """ + Random layer with a wide range of quantum gate types. + + This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. + + Args: + wires (int or list): Indices of the wires the operations are applied to. + n_ops (int): Number of operations in the layer. + n_params (int): Number of parameters for each operation. + op_ratios (list): Ratios for selecting different types of operations. + op_types (tuple): Types of operations to include in the layer. + seed (int): Seed for the random number generator. + qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. + + """ + + def __init__( + self, + wires, + n_ops=None, + n_params=None, + op_ratios=None, + op_types=( + tq.Hadamard, + tq.SHadamard, + tq.PauliX, + tq.PauliY, + tq.PauliZ, + tq.S, + tq.T, + tq.SX, + tq.CNOT, + tq.CZ, + tq.CY, + tq.RX, + tq.RY, + tq.RZ, + tq.RZZ, + tq.SWAP, + tq.CSWAP, + tq.Toffoli, + tq.PhaseShift, + tq.Rot, + tq.MultiRZ, + tq.CRX, + tq.CRY, + tq.CRZ, + tq.CRot, + tq.U1, + tq.U2, + tq.U3, + tq.MultiCNOT, + tq.MultiXCNOT, + ), + seed=None, + qiskit_compatible=False, + ): + super().__init__( + wires=wires, + n_ops=n_ops, + n_params=n_params, + op_ratios=op_ratios, + op_types=op_types, + seed=seed, + qiskit_compatible=qiskit_compatible, + ) From 56ef548bc9ca95c3b2607081ccb8ddbd2522c44c Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 23 Dec 2023 15:17:53 -0600 Subject: [PATCH 061/106] [minor] bugfix: rm unused variable in __all__ --- torchquantum/layer/layers/op_all.py | 1 - 1 file changed, 1 deletion(-) diff --git a/torchquantum/layer/layers/op_all.py b/torchquantum/layer/layers/op_all.py index 5b813907..33478781 100644 --- a/torchquantum/layer/layers/op_all.py +++ b/torchquantum/layer/layers/op_all.py @@ -38,7 +38,6 @@ "ClassicalInOpAll", "FixedOpAll", "TwoQAll", - "Op1QAllLayer", ] From 0fad677d15d5f681ff0065144c6ecc3467384bcd Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 23 Dec 2023 16:09:41 -0600 Subject: [PATCH 062/106] completed inital layer break up --- torchquantum/layer/__init__.py | 1 + torchquantum/layer/entanglement/__init__.py | 9 + .../layer/entanglement/entanglement.py | 284 +++ torchquantum/layer/entanglement/op2_layer.py | 203 ++ torchquantum/layer/general/globalr.py | 5 +- torchquantum/layer/layers.py | 1852 ----------------- torchquantum/layer/layers/__init__.py | 45 +- torchquantum/layer/layers/cx_layer.py | 77 + torchquantum/layer/layers/layers.py | 581 +----- torchquantum/layer/layers/qft_layer.py | 117 ++ torchquantum/layer/layers/ry_layer.py | 150 ++ torchquantum/layer/layers/seth_layer.py | 172 ++ torchquantum/layer/layers/swap_layer.py | 86 + torchquantum/layer/layers/u3_layer.py | 118 ++ torchquantum/layer/nlocal/nlocal.py | 2 +- torchquantum/layer/nlocal/two_local.py | 2 + 16 files changed, 1281 insertions(+), 2423 deletions(-) create mode 100644 torchquantum/layer/entanglement/__init__.py create mode 100644 torchquantum/layer/entanglement/entanglement.py create mode 100644 torchquantum/layer/entanglement/op2_layer.py delete mode 100644 torchquantum/layer/layers.py create mode 100644 torchquantum/layer/layers/cx_layer.py create mode 100644 torchquantum/layer/layers/qft_layer.py create mode 100644 torchquantum/layer/layers/ry_layer.py create mode 100644 torchquantum/layer/layers/seth_layer.py create mode 100644 torchquantum/layer/layers/swap_layer.py create mode 100644 torchquantum/layer/layers/u3_layer.py diff --git a/torchquantum/layer/__init__.py b/torchquantum/layer/__init__.py index ce5540cb..52312502 100644 --- a/torchquantum/layer/__init__.py +++ b/torchquantum/layer/__init__.py @@ -25,3 +25,4 @@ from .layers import * from .nlocal import * from .general import * +from .entanglement import * diff --git a/torchquantum/layer/entanglement/__init__.py b/torchquantum/layer/entanglement/__init__.py new file mode 100644 index 00000000..1dc015f8 --- /dev/null +++ b/torchquantum/layer/entanglement/__init__.py @@ -0,0 +1,9 @@ +from .entanglement import ( + EntangleLinear, + EntanglePairwise, + EntangleFull, + EntangleCircular, + EntanglementLayer, + Op2QDenseLayer, +) +from .op2_layer import Op2QAllLayer, Op2QFit32Layer, Op2QButterflyLayer diff --git a/torchquantum/layer/entanglement/entanglement.py b/torchquantum/layer/entanglement/entanglement.py new file mode 100644 index 00000000..9f1a6cfd --- /dev/null +++ b/torchquantum/layer/entanglement/entanglement.py @@ -0,0 +1,284 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +# from torchquantum.layer.layers import ( +# Op1QAllLayer, +# RandomOp1All, +# ) +from .op2_layer import Op2QAllLayer + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +__all__ = [ + "EntangleLinear", + "EntanglePairwise", + "EntangleFull", + "EntangleCircular", + "Op2QDenseLayer", + "EntanglementLayer", +] + + +class EntangleFull(tq.QuantumModule): + """ + Quantum layer applying the same two-qubit operation in a dense pattern. + + This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ + + """pattern: + [0, 1], [0, 2], [0, 3], [0, 4], [0, 5] + [1, 2], [1, 3], [1, 4], [1, 5] + [2, 3], [2, 4], [2, 5] + [3, 4], [3, 5] + [4, 5] + """ + + def __init__( + self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False + ): + super().__init__() + self.n_wires = n_wires + self.op = op + self.ops_all = tq.QuantumModuleList() + + # reverse the wires, for example from [1, 2] to [2, 1] + self.wire_reverse = wire_reverse + + for k in range(self.n_wires * (self.n_wires - 1) // 2): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + def forward(self, q_device): + k = 0 + for i in range(self.n_wires - 1): + for j in range(i + 1, self.n_wires): + wires = [i, j] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + k += 1 + + +# Adding an alias to the previous name +Op2QDenseLayer = EntangleFull + + +class EntangleLinear(Op2QAllLayer): + """ + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + """ + + """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] + """ + + def __init__( + self, + op, + n_wires: int, + has_params=False, + trainable=False, + wire_reverse=False, + ): + super().__init__( + op=op, + n_wires=n_wires, + has_params=has_params, + trainable=trainable, + wire_reverse=wire_reverse, + jump=1, + circular=False, + ) + + +class EntangleCircular(Op2QAllLayer): + """ + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires in a circular manner. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device with a wrap-around + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ + + """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] + """ + + def __init__( + self, + op, + n_wires: int, + has_params=False, + trainable=False, + wire_reverse=False, + ): + super().__init__( + op=op, + n_wires=n_wires, + has_params=has_params, + trainable=trainable, + wire_reverse=wire_reverse, + jump=1, + circular=True, + ) + + +class EntanglePairwise(tq.QuantumModule): + """ + Quantum layer applying the same two-qubit operation in a pair-wise pattern + + This class represents a quantum layer that applies the same two-qubit operation in a pairwise pattern. The pairwise pattern first entangles all qubits i with i+1 for even i then all qubits i with i+1 for odd i. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ + + """pattern: + [0, 1], [2, 3], [4, 5] + [1, 2], [3, 4] + """ + + def __init__( + self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False + ): + super().__init__() + self.n_wires = n_wires + self.op = op + self.ops_all = tq.QuantumModuleList() + + # reverse the wires, for example from [1, 2] to [2, 1] + self.wire_reverse = wire_reverse + + for k in range(self.n_wires - 1): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + def forward(self, q_device): + k = 0 + + # entangle qubit i with i+1 for all even values of i + for i in range(self.n_wires - 1): + if i % 2 == 0: + wires = [i, i + 1] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + k += 1 + + # entangle qubit i with i+1 for all odd values of i + for i in range(1, self.n_wires - 1): + if i % 2 == 1: + wires = [i, i + 1] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + k += 1 + + +class EntanglementLayer(tq.QuantumModule): + """ + Quantum layer applying a specified two-qubit entanglement type to all qubits. The entanglement types include full, linear, pairwise, and circular. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + entanglement (str): Type of entanglement from ["full", "linear", "pairwise", "circular"] + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ + + def __init__( + self, + op, + n_wires: int, + entanglement: str, + has_params=False, + trainable=False, + wire_reverse=False, + ): + super().__init__() + + entanglement_to_class = { + "full": EntangleFull, + "linear": EntangleLinear, + "pairwise": EntanglePairwise, + "circular": EntangleCircular, + } + + self.entanglement_class = entanglement_to_class.get(entanglement, None) + + assert ( + self.entanglement_class is not None + ), f"invalid entanglement type {entanglement}" + + self.entanglement_class.__init__( + op=op, + n_wires=n_wires, + has_params=has_params, + trainable=trainable, + wire_reverse=wire_reverse, + ) + + @tq.static_support + def forward(self, q_device): + self.entanglement_class.forward(q_device) diff --git a/torchquantum/layer/entanglement/op2_layer.py b/torchquantum/layer/entanglement/op2_layer.py new file mode 100644 index 00000000..edf120dc --- /dev/null +++ b/torchquantum/layer/entanglement/op2_layer.py @@ -0,0 +1,203 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +__all__ = [ + "Op2QAllLayer", + "Op2QFit32Layer", + "Op2QButterflyLayer", +] + + +class Op2QAllLayer(tq.QuantumModule): + """ + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires + in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the + specified jump. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ + + """pattern: + circular = False + jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] + jump = 2: [0, 2], [1, 3], [2, 4], [3, 5] + jump = 3: [0, 3], [1, 4], [2, 5] + jump = 4: [0, 4], [1, 5] + jump = 5: [0, 5] + + circular = True + jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] + jump = 2: [0, 2], [1, 3], [2, 4], [3, 5], [4, 0], [5, 1] + jump = 3: [0, 3], [1, 4], [2, 5], [3, 0], [4, 1], [5, 2] + jump = 4: [0, 4], [1, 5], [2, 0], [3, 1], [4, 2], [5, 3] + jump = 5: [0, 5], [1, 0], [2, 1], [3, 2], [4, 3], [5, 4] + """ + + def __init__( + self, + op, + n_wires: int, + has_params=False, + trainable=False, + wire_reverse=False, + jump=1, + circular=False, + ): + super().__init__() + self.n_wires = n_wires + self.jump = jump + self.circular = circular + self.op = op + self.ops_all = tq.QuantumModuleList() + + # reverse the wires, for example from [1, 2] to [2, 1] + self.wire_reverse = wire_reverse + + if circular: + n_ops = n_wires + else: + n_ops = n_wires - jump + for k in range(n_ops): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + @tq.static_support + def forward(self, q_device): + for k in range(len(self.ops_all)): + wires = [k, (k + self.jump) % self.n_wires] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + + +class Op2QFit32Layer(tq.QuantumModule): + """ + Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. + + This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. + circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. + + """ + + def __init__( + self, + op, + n_wires: int, + has_params=False, + trainable=False, + wire_reverse=False, + jump=1, + circular=False, + ): + super().__init__() + self.n_wires = n_wires + self.jump = jump + self.circular = circular + self.op = op + self.ops_all = tq.QuantumModuleList() + + # reverse the wires, for example from [1, 2] to [2, 1] + self.wire_reverse = wire_reverse + + # if circular: + # n_ops = n_wires + # else: + # n_ops = n_wires - jump + n_ops = 32 + for k in range(n_ops): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + @tq.static_support + def forward(self, q_device): + for k in range(len(self.ops_all)): + wires = [k % self.n_wires, (k + self.jump) % self.n_wires] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) + + +class Op2QButterflyLayer(tq.QuantumModule): + """ + Quantum layer applying the same two-qubit operation in a butterfly pattern. + + This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. + + Args: + op (tq.Operator): Two-qubit operation to be applied. + n_wires (int): Number of wires in the quantum device. + has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. + trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. + wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. + + """ + + """pattern: [0, 5], [1, 4], [2, 3]""" + + def __init__( + self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False + ): + super().__init__() + self.n_wires = n_wires + self.op = op + self.ops_all = tq.QuantumModuleList() + + # reverse the wires, for example from [1, 2] to [2, 1] + self.wire_reverse = wire_reverse + + for k in range(n_wires // 2): + self.ops_all.append(op(has_params=has_params, trainable=trainable)) + + def forward(self, q_device): + for k in range(len(self.ops_all)): + wires = [k, self.n_wires - 1 - k] + if self.wire_reverse: + wires.reverse() + self.ops_all[k](q_device, wires=wires) diff --git a/torchquantum/layer/general/globalr.py b/torchquantum/layer/general/globalr.py index 9857220a..34016676 100644 --- a/torchquantum/layer/general/globalr.py +++ b/torchquantum/layer/general/globalr.py @@ -28,9 +28,9 @@ from torchquantum.layer.layers import ( LayerTemplate0, Op1QAllLayer, - Op2QAllLayer, RandomOp1All, ) +from torchquantum.layer.entanglement import Op2QAllLayer __all__ = [ "GlobalR", @@ -83,6 +83,7 @@ def __init__( """Create the layer""" super().__init__(n_wires, theta, phi=torch.pi / 2) + class GlobalRZ(tq.QuantumModule): """Layer Template for a Global RZ General Gate""" @@ -100,5 +101,3 @@ def __init__( def forward(self, q_device, x=None): for k in range(self.n_wires): tq.RZ()(q_device, wires=k, params=self.params) - - diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py deleted file mode 100644 index e5eceeb2..00000000 --- a/torchquantum/layer/layers.py +++ /dev/null @@ -1,1852 +0,0 @@ -""" -MIT License - -Copyright (c) 2020-present TorchQuantum Authors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -""" - -import torch -import torch.nn as nn -import torchquantum as tq -import torchquantum.functional as tqf -import numpy as np - - -from typing import Iterable -from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES -from torchpack.utils.logging import logger - -__all__ = [ - "QuantumModuleFromOps", - "TrainableOpAll", - "ClassicalInOpAll", - "FixedOpAll", - "TwoQAll", - "RandomLayer", - "RandomLayerAllTypes", - "Op1QAllLayer", - "RandomOp1All", - "Op2QAllLayer", - "Op2QButterflyLayer", - "Op2QDenseLayer", - "layer_name_dict", - "CXLayer", - "CXCXCXLayer", - "SWAPSWAPLayer", - "RXYZCXLayer0", - "QFTLayer", - "EntangleLinear", - "EntanglePairwise", - "EntangleFull", - "EntangleCircular", - "EntanglementLayer", -] - - -class QuantumModuleFromOps(tq.QuantumModule): - """Initializes a QuantumModuleFromOps instance. - - Args: - ops (List[tq.Operation]): List of quantum operations. - - """ - - def __init__(self, ops): - super().__init__() - self.ops = tq.QuantumModuleList(ops) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - """Performs the forward pass of the quantum module. - - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - - Returns: - None - - """ - self.q_device = q_device - for op in self.ops: - op(q_device) - - -class TrainableOpAll(tq.QuantumModule): - """Rotation rx on all qubits - The rotation angle is a parameter of each rotation gate - One potential optimization is to compute the unitary of all gates - together. - """ - - def __init__(self, n_gate: int, op: tq.Operation): - super().__init__() - self.n_gate = n_gate - self.gate_all = nn.ModuleList() - for k in range(self.n_gate): - self.gate_all.append(op(has_params=True, trainable=True)) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - # rx on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of rx gates ({self.n_gate}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_gate): - self.gate_all[k](q_device, wires=k) - - -class ClassicalInOpAll(tq.QuantumModule): - """ - Quantum module that applies the same quantum operation to all wires of a quantum device, - where the parameters of the operation are obtained from a classical input. - - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. - - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. - - """ - - def __init__(self, n_gate: int, op: tq.Operator): - super().__init__() - self.n_gate = n_gate - self.gate_all = nn.ModuleList() - for k in range(self.n_gate): - self.gate_all.append(op()) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice, x): - """ - Performs the forward pass of the classical input quantum operation module. - - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - x (torch.Tensor): Classical input of shape (batch_size, n_gate). - - Returns: - None - - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. - - """ - # rx on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of rx gates ({self.n_gate}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_gate): - self.gate_all[k](q_device, wires=k, params=x[:, k]) - - -class FixedOpAll(tq.QuantumModule): - """ - Quantum module that applies the same fixed quantum operation to all wires of a quantum device. - - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. - - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. - - """ - - def __init__(self, n_gate: int, op: tq.Operator): - super().__init__() - self.n_gate = n_gate - self.gate_all = nn.ModuleList() - for k in range(self.n_gate): - self.gate_all.append(op()) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - """ - Performs the forward pass of the fixed quantum operation module. - - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - - Returns: - None - - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. - - """ - # rx on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of rx gates ({self.n_gate}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_gate): - self.gate_all[k](q_device, wires=k) - - -class TwoQAll(tq.QuantumModule): - """ - Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. - - Args: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation to be applied. - - Attributes: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation. - - """ - - def __init__(self, n_gate: int, op: tq.Operator): - super().__init__() - self.n_gate = n_gate - self.op = op() - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - for k in range(self.n_gate - 1): - self.op(q_device, wires=[k, k + 1]) - self.op(q_device, wires=[self.n_gate - 1, 0]) - - -class RandomOp1All(tq.QuantumModule): - def __init__( - self, - n_wires: int, - op_types=(tq.RX, tq.RY, tq.RZ), - op_ratios=None, - has_params=True, - trainable=True, - seed=None, - ): - """Layer adding a random gate to all wires - - Params: - n_wires (int): number of wires/gates in integer format - op_types (Iterable): single-wire gates to select from in iterable format - op_ratios (Iterable): probabilities to select each gate option in iterable format - seed (int): random seed in integer format - """ - super().__init__() - self.n_wires = n_wires - self.op_types = op_types - self.op_ratios = op_ratios - self.seed = seed - self.gate_all = nn.ModuleList() - - if seed is not None: - np.random.seed(seed) - - for k in range(self.n_wires): - op = np.random.choice(self.op_types, p=self.op_ratios) - self.gate_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - for k in range(self.n_wires): - self.gate_all[k](q_device, wires=k) - - -class RandomLayer(tq.QuantumModule): - """ - Quantum module that represents a random layer of quantum operations applied to specified wires. - - Args: - wires (int or Iterable[int]): Indices of the wires the operations are applied to. - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - op_ratios (list or float): Ratios determining the relative frequencies of different operation types. - op_types (tuple or tq.Operator): Types of random operations to be included in the layer. - seed (int): Seed for random number generation. - qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. - - Attributes: - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - wires (list): Indices of the wires the operations are applied to. - n_wires (int): Number of wires. - op_types (list): Types of random operations included in the layer. - op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. - seed (int): Seed for random number generation. - op_list (tq.QuantumModuleList): List of random operations in the layer. - - """ - - def __init__( - self, - wires, - n_ops=None, - n_params=None, - op_ratios=None, - op_types=(tq.RX, tq.RY, tq.RZ, tq.CNOT), - seed=None, - qiskit_compatible=False, - ): - super().__init__() - self.n_ops = n_ops - self.n_params = n_params - assert n_params is not None or n_ops is not None - self.wires = wires if isinstance(wires, Iterable) else [wires] - self.n_wires = len(wires) - - op_types = op_types if isinstance(op_types, Iterable) else [op_types] - if op_ratios is None: - op_ratios = [1] * len(op_types) - else: - op_ratios = op_ratios if isinstance(op_ratios, Iterable) else [op_ratios] - op_types_valid = [] - op_ratios_valid = [] - - if qiskit_compatible: - for op_type, op_ratio in zip(op_types, op_ratios): - if op_type().name.lower() in QISKIT_INCOMPATIBLE_FUNC_NAMES: - logger.warning( - f"Remove {op_type} from op_types to make " - f"the layer qiskit-compatible." - ) - else: - op_types_valid.append(op_type) - op_ratios_valid.append(op_ratio) - else: - op_types_valid = op_types - op_ratios_valid = op_ratios - - self.op_types = op_types_valid - self.op_ratios = np.array(op_ratios_valid) / sum(op_ratios_valid) - - self.seed = seed - self.op_list = tq.QuantumModuleList() - if seed is not None: - np.random.seed(seed) - self.build_random_layer() - - def rebuild_random_layer_from_op_list(self, n_ops_in, wires_in, op_list_in): - """ - Rebuilds a random layer from the given operation list. - This method is used for loading a random layer from a checkpoint. - - Args: - n_ops_in (int): Number of operations in the layer. - wires_in (list): Indices of the wires the operations are applied to. - op_list_in (list): List of operations in the layer. - - """ - - self.n_ops = n_ops_in - self.wires = wires_in - self.op_list = tq.QuantumModuleList() - for op_in in op_list_in: - op = tq.op_name_dict[op_in.name.lower()]( - has_params=op_in.has_params, - trainable=op_in.trainable, - wires=op_in.wires, - n_wires=op_in.n_wires, - ) - self.op_list.append(op) - - def build_random_layer(self): - op_cnt = 0 - param_cnt = 0 - while True: - op = np.random.choice(self.op_types, p=self.op_ratios) - n_op_wires = op.num_wires - if n_op_wires > self.n_wires: - continue - if n_op_wires == -1: - is_AnyWire = True - n_op_wires = self.n_wires - else: - is_AnyWire = False - - op_wires = list( - np.random.choice(self.wires, size=n_op_wires, replace=False) - ) - if is_AnyWire: - if op().name in ["MultiRZ"]: - operation = op( - has_params=True, - trainable=True, - n_wires=n_op_wires, - wires=op_wires, - ) - else: - operation = op(n_wires=n_op_wires, wires=op_wires) - elif op().name in tq.operator.parameterized_ops: - operation = op(has_params=True, trainable=True, wires=op_wires) - else: - operation = op(wires=op_wires) - self.op_list.append(operation) - op_cnt += 1 - param_cnt += op.num_params - - if self.n_ops is not None and op_cnt == self.n_ops: - break - elif self.n_ops is None and self.n_params is not None: - if param_cnt == self.n_params: - break - elif param_cnt > self.n_params: - """ - the last operation has too many params and exceed the - constraint, so need to remove it and sample another - """ - op_cnt -= 1 - param_cnt -= op.num_params - del self.op_list[-1] - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - for op in self.op_list: - op(q_device) - - -class RandomLayerAllTypes(RandomLayer): - """ - Random layer with a wide range of quantum gate types. - - This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. - - Args: - wires (int or list): Indices of the wires the operations are applied to. - n_ops (int): Number of operations in the layer. - n_params (int): Number of parameters for each operation. - op_ratios (list): Ratios for selecting different types of operations. - op_types (tuple): Types of operations to include in the layer. - seed (int): Seed for the random number generator. - qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. - - """ - - def __init__( - self, - wires, - n_ops=None, - n_params=None, - op_ratios=None, - op_types=( - tq.Hadamard, - tq.SHadamard, - tq.PauliX, - tq.PauliY, - tq.PauliZ, - tq.S, - tq.T, - tq.SX, - tq.CNOT, - tq.CZ, - tq.CY, - tq.RX, - tq.RY, - tq.RZ, - tq.RZZ, - tq.SWAP, - tq.CSWAP, - tq.Toffoli, - tq.PhaseShift, - tq.Rot, - tq.MultiRZ, - tq.CRX, - tq.CRY, - tq.CRZ, - tq.CRot, - tq.U1, - tq.U2, - tq.U3, - tq.MultiCNOT, - tq.MultiXCNOT, - ), - seed=None, - qiskit_compatible=False, - ): - super().__init__( - wires=wires, - n_ops=n_ops, - n_params=n_params, - op_ratios=op_ratios, - op_types=op_types, - seed=seed, - qiskit_compatible=qiskit_compatible, - ) - - -class SimpleQLayer(tq.QuantumModule): - """ - Simple quantum layer consisting of three parameterized gates applied to specific wires. - - This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - self.gate1 = tq.RX(has_params=True, trainable=True) - self.gate2 = tq.RY(has_params=True, trainable=True) - self.gate3 = tq.RZ(has_params=True, trainable=True) - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.x(q_dev, wires=0, static=self.static_mode, parent_graph=self.graph) - self.gate1(q_dev, wires=1) - self.gate2(q_dev, wires=1) - self.gate3(q_dev, wires=1) - tqf.x(q_dev, wires=2, static=self.static_mode, parent_graph=self.graph) - - -class CXLayer(tq.QuantumModule): - """ - Quantum layer with a controlled-X (CX) gate applied to two specified wires. - - This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - - -class CXCXCXLayer(tq.QuantumModule): - """ - Quantum layer with a sequence of CX gates applied to three specified wires. - - This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - tqf.cnot(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) - tqf.cnot(q_dev, wires=[2, 0], static=self.static_mode, parent_graph=self.graph) - - -class SWAPSWAPLayer(tq.QuantumModule): - """ - Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. - - This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.swap(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - tqf.swap(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) - - -class Op1QAllLayer(tq.QuantumModule): - """ - Quantum layer applying the same single-qubit operation to all wires. - - This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. - - Args: - op (tq.Operator): Single-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - - """ - - def __init__(self, op, n_wires: int, has_params=False, trainable=False): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - for k in range(n_wires): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device): - for k in range(self.n_wires): - self.ops_all[k](q_device, wires=k) - - -class Op2QAllLayer(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the - specified jump. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - """pattern: - circular = False - jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] - jump = 2: [0, 2], [1, 3], [2, 4], [3, 5] - jump = 3: [0, 3], [1, 4], [2, 5] - jump = 4: [0, 4], [1, 5] - jump = 5: [0, 5] - - circular = True - jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] - jump = 2: [0, 2], [1, 3], [2, 4], [3, 5], [4, 0], [5, 1] - jump = 3: [0, 3], [1, 4], [2, 5], [3, 0], [4, 1], [5, 2] - jump = 4: [0, 4], [1, 5], [2, 0], [3, 1], [4, 2], [5, 3] - jump = 5: [0, 5], [1, 0], [2, 1], [3, 2], [4, 3], [5, 4] - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - jump=1, - circular=False, - ): - super().__init__() - self.n_wires = n_wires - self.jump = jump - self.circular = circular - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - if circular: - n_ops = n_wires - else: - n_ops = n_wires - jump - for k in range(n_ops): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device): - for k in range(len(self.ops_all)): - wires = [k, (k + self.jump) % self.n_wires] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - - -class Op2QFit32Layer(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. - - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - jump=1, - circular=False, - ): - super().__init__() - self.n_wires = n_wires - self.jump = jump - self.circular = circular - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - # if circular: - # n_ops = n_wires - # else: - # n_ops = n_wires - jump - n_ops = 32 - for k in range(n_ops): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device): - for k in range(len(self.ops_all)): - wires = [k % self.n_wires, (k + self.jump) % self.n_wires] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - - -class Op2QButterflyLayer(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation in a butterfly pattern. - - This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - - """ - - """pattern: [0, 5], [1, 4], [2, 3]""" - - def __init__( - self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False - ): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - for k in range(n_wires // 2): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - def forward(self, q_device): - for k in range(len(self.ops_all)): - wires = [k, self.n_wires - 1 - k] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - - -class EntangleFull(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation in a dense pattern. - - This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - - """ - - """pattern: - [0, 1], [0, 2], [0, 3], [0, 4], [0, 5] - [1, 2], [1, 3], [1, 4], [1, 5] - [2, 3], [2, 4], [2, 5] - [3, 4], [3, 5] - [4, 5] - """ - - def __init__( - self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False - ): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - for k in range(self.n_wires * (self.n_wires - 1) // 2): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - def forward(self, q_device): - k = 0 - for i in range(self.n_wires - 1): - for j in range(i + 1, self.n_wires): - wires = [i, j] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - k += 1 - - -# Adding an alias to the previous name -Op2QDenseLayer = EntangleFull - - -class LayerTemplate0(tq.QuantumModule): - """ - A template for a custom quantum layer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. (Optional) - n_layers_per_block (int): The number of layers per block. (Optional) - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Abstract method to build the layers of the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def __init__(self, arch: dict = None): - super().__init__() - self.n_wires = arch["n_wires"] - self.arch = arch - - self.n_blocks = arch.get("n_blocks", None) - self.n_layers_per_block = arch.get("n_layers_per_block", None) - - self.layers_all = self.build_layers() - - def build_layers(self): - raise NotImplementedError - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - self.q_device = q_device - for k in range(len(self.layers_all)): - self.layers_all[k](q_device) - - -class U3CU3Layer0(LayerTemplate0): - """ - Layer template with U3 and CU3 blocks. - - This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the U3 and CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.U3, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class CU3Layer0(LayerTemplate0): - """ - Layer template with CU3 blocks. - - This layer template consists of CU3 blocks repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=False, - ) - ) - return layers_all - - -class CXRZSXLayer0(LayerTemplate0): - """ - Layer template with CXRZSX blocks. - - This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the CXRZSX layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=False) - ) - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.SX, n_wires=self.n_wires, has_params=False, trainable=False - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class SethLayer0(LayerTemplate0): - """ - Layer template with Seth blocks. - - This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class SethLayer1(LayerTemplate0): - """ - Layer template with extended Seth blocks. - - This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the extended Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class SethLayer2(LayerTemplate0): - """ - Layer template with Seth blocks using Op2QFit32Layer. - - This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Seth layers with Op2QFit32Layer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QFit32Layer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class RZZLayer0(LayerTemplate0): - """ - Layer template with RZZ blocks. - - This layer template consists of RZZ blocks using the Op2QAllLayer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RZZ layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class BarrenLayer0(LayerTemplate0): - """ - Layer template with Barren blocks. - - This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - layers_all.append( - Op1QAllLayer( - op=tq.SHadamard, - n_wires=self.n_wires, - ) - ) - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op2QAllLayer(op=tq.CZ, n_wires=self.n_wires, jump=1)) - return layers_all - - -class FarhiLayer0(LayerTemplate0): - """ - Layer template with Farhi blocks. - - This layer template consists of Farhi blocks using the Op2QAllLayer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Farhi layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZX, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.RXX, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class MaxwellLayer0(LayerTemplate0): - """ - Layer template with Maxwell blocks. - - This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op1QAllLayer(op=tq.S, n_wires=self.n_wires)) - layers_all.append( - Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) - ) - - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op1QAllLayer(op=tq.T, n_wires=self.n_wires)) - layers_all.append( - Op2QAllLayer(op=tq.SWAP, n_wires=self.n_wires, jump=1, circular=True) - ) - - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op1QAllLayer(op=tq.Hadamard, n_wires=self.n_wires)) - layers_all.append( - Op2QAllLayer(op=tq.SSWAP, n_wires=self.n_wires, jump=1, circular=True) - ) - - layers_all.append( - Op1QAllLayer( - op=tq.U1, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - - return layers_all - - -class RYRYCXLayer0(LayerTemplate0): - """ - Layer template with RYRYCX blocks. - - This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(CXLayer(n_wires=self.n_wires)) - return layers_all - - -class RYRYRYCXCXCXLayer0(LayerTemplate0): - """ - Layer template with RYRYRYCXCXCX blocks. - - This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(CXCXCXLayer(n_wires=self.n_wires)) - return layers_all - - -class RYRYRYLayer0(LayerTemplate0): - """ - Layer template with RYRYRYCXCXCX blocks. - - This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. - - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class RYRYRYSWAPSWAPLayer0(LayerTemplate0): - """ - Layer template with RYRYRYSWAPSWAP blocks. - - This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. - - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) - return layers_all - - -class SWAPSWAPLayer0(LayerTemplate0): - """ - Layer template with SWAPSWAP blocks. - - This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) - return layers_all - - -class RXYZCXLayer0(LayerTemplate0): - """ - Layer template with RXYZCX blocks. - - This layer template consists of RXYZCX blocks using the RXYZCXLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) - ) - return layers_all - - -class QFTLayer(tq.QuantumModule): - def __init__( - self, - n_wires: int = None, - wires: Iterable = None, - do_swaps: bool = True, - inverse: bool = False, - ): - """ - Constructs a Quantum Fourier Transform (QFT) layer - - Args: - n_wires (int): Number of wires for the QFT as an integer - wires (Iterable): Wires to perform the QFT as an Iterable - do_swaps (bool): Whether or not to add the final swaps in a boolean format - inverse (bool): Whether to create an inverse QFT layer in a boolean format - """ - super().__init__() - - assert n_wires is not None or wires is not None - - if n_wires is None: - self.n_wires = len(wires) - - if wires is None: - wires = range(n_wires) - - self.n_wires = n_wires - self.wires = wires - self.do_swaps = do_swaps - - if inverse: - self.gates_all = self.build_inverse_circuit() - else: - self.gates_all = self.build_circuit() - - def build_circuit(self): - """Construct a QFT circuit.""" - - operation_list = [] - - # add the H and CU1 gates - for top_wire in range(self.n_wires): - operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) - for wire in range(top_wire + 1, self.n_wires): - lam = torch.pi / (2 ** (wire - top_wire)) - operation_list.append( - { - "name": "cu1", - "params": lam, - "wires": [self.wires[wire], self.wires[top_wire]], - } - ) - - # add swaps if specified - if self.do_swaps: - for wire in range(self.n_wires // 2): - operation_list.append( - { - "name": "swap", - "wires": [ - self.wires[wire], - self.wires[self.n_wires - wire - 1], - ], - } - ) - - return tq.QuantumModule.from_op_history(operation_list) - - def build_inverse_circuit(self): - """Construct the inverse of a QFT circuit.""" - - operation_list = [] - - # add swaps if specified - if self.do_swaps: - for wire in range(self.n_wires // 2): - operation_list.append( - { - "name": "swap", - "wires": [ - self.wires[wire], - self.wires[self.n_wires - wire - 1], - ], - } - ) - - # add the CU1 and H gates - for top_wire in range(self.n_wires)[::-1]: - for wire in range(top_wire + 1, self.n_wires)[::-1]: - lam = -torch.pi / (2 ** (wire - top_wire)) - operation_list.append( - { - "name": "cu1", - "params": lam, - "wires": [self.wires[wire], self.wires[top_wire]], - } - ) - operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) - - return tq.QuantumModule.from_op_history(operation_list) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - self.gates_all(q_device) - - -class EntangleLinear(Op2QAllLayer): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - """ - - """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - ): - super().__init__( - op=op, - n_wires=n_wires, - has_params=has_params, - trainable=trainable, - wire_reverse=wire_reverse, - jump=1, - circular=False, - ) - - -class EntangleCircular(Op2QAllLayer): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires in a circular manner. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device with a wrap-around - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - ): - super().__init__( - op=op, - n_wires=n_wires, - has_params=has_params, - trainable=trainable, - wire_reverse=wire_reverse, - jump=1, - circular=True, - ) - - -class EntanglePairwise(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation in a pair-wise pattern - - This class represents a quantum layer that applies the same two-qubit operation in a pairwise pattern. The pairwise pattern first entangles all qubits i with i+1 for even i then all qubits i with i+1 for odd i. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - - """ - - """pattern: - [0, 1], [2, 3], [4, 5] - [1, 2], [3, 4] - """ - - def __init__( - self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False - ): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - for k in range(self.n_wires - 1): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - def forward(self, q_device): - k = 0 - - # entangle qubit i with i+1 for all even values of i - for i in range(self.n_wires - 1): - if i % 2 == 0: - wires = [i, i + 1] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - k += 1 - - # entangle qubit i with i+1 for all odd values of i - for i in range(1, self.n_wires - 1): - if i % 2 == 1: - wires = [i, i + 1] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - k += 1 - - -class EntanglementLayer(tq.QuantumModule): - """ - Quantum layer applying a specified two-qubit entanglement type to all qubits. The entanglement types include full, linear, pairwise, and circular. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - entanglement (str): Type of entanglement from ["full", "linear", "pairwise", "circular"] - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - def __init__( - self, - op, - n_wires: int, - entanglement: str, - has_params=False, - trainable=False, - wire_reverse=False, - ): - super().__init__() - - entanglement_to_class = { - "full": EntangleFull, - "linear": EntangleLinear, - "pairwise": EntanglePairwise, - "circular": EntangleCircular, - } - - self.entanglement_class = entanglement_to_class.get(entanglement, None) - - assert ( - self.entanglement_class is not None - ), f"invalid entanglement type {entanglement}" - - self.entanglement_class.__init__( - op=op, - n_wires=n_wires, - has_params=has_params, - trainable=trainable, - wire_reverse=wire_reverse, - ) - - @tq.static_support - def forward(self, q_device): - self.entanglement_class.forward(q_device) - - -layer_name_dict = { - "u3cu3_0": U3CU3Layer0, - "cu3_0": CU3Layer0, - "cxrzsx_0": CXRZSXLayer0, - "seth_0": SethLayer0, - "seth_1": SethLayer1, - "seth_2": SethLayer2, - "rzz_0": RZZLayer0, - "barren_0": BarrenLayer0, - "farhi_0": FarhiLayer0, - "maxwell_0": MaxwellLayer0, - "ryrycx": RYRYCXLayer0, - "ryryrycxcxcx": RYRYRYCXCXCXLayer0, - "ryryry": RYRYRYLayer0, - "swapswap": SWAPSWAPLayer0, - "ryryryswapswap": RYRYRYSWAPSWAPLayer0, - "rxyzcx_0": RXYZCXLayer0, -} diff --git a/torchquantum/layer/layers/__init__.py b/torchquantum/layer/layers/__init__.py index 25ebfa78..10206837 100644 --- a/torchquantum/layer/layers/__init__.py +++ b/torchquantum/layer/layers/__init__.py @@ -1,4 +1,47 @@ from .module_from_ops import QuantumModuleFromOps from .op_all import TrainableOpAll, ClassicalInOpAll, FixedOpAll, TwoQAll from .random_layers import RandomLayer, RandomLayerAllTypes, RandomOp1All -from .layers import * +from .swap_layer import SWAPSWAPLayer, SWAPSWAPLayer0 +from .cx_layer import CXLayer, CXCXCXLayer +from .ry_layer import ( + RYRYCXLayer0, + RYRYRYCXCXCXLayer0, + RYRYRYLayer0, + RYRYRYSWAPSWAPLayer0, +) +from .u3_layer import U3CU3Layer0, CU3Layer0 +from .qft_layer import QFTLayer +from .seth_layer import SethLayer0, SethLayer1, SethLayer2 +from .layers import ( + SimpleQLayer, + Op1QAllLayer, + LayerTemplate0, + CXRZSXLayer0, + RZZLayer0, + BarrenLayer0, + FarhiLayer0, + MaxwellLayer0, + RXYZCXLayer0, +) + +# layer (children of LayerTemplate0) to add to the layer_name_dict +_all_layers = [ + SWAPSWAPLayer0, + RYRYCXLayer0, + RYRYRYCXCXCXLayer0, + RYRYRYLayer0, + RYRYRYSWAPSWAPLayer0, + CXRZSXLayer0, + RZZLayer0, + BarrenLayer0, + FarhiLayer0, + MaxwellLayer0, + RXYZCXLayer0, +] + +layer_name_dict = {} + +for _lyr in _all_layers: + # check the layer has a non-empty name + assert _lyr.name is not None, f"Layer name not defined for {layer}" + layer_name_dict[_lyr.name] = _lyr diff --git a/torchquantum/layer/layers/cx_layer.py b/torchquantum/layer/layers/cx_layer.py new file mode 100644 index 00000000..320d600d --- /dev/null +++ b/torchquantum/layer/layers/cx_layer.py @@ -0,0 +1,77 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + + +class CXLayer(tq.QuantumModule): + """ + Quantum layer with a controlled-X (CX) gate applied to two specified wires. + + This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) + + +class CXCXCXLayer(tq.QuantumModule): + """ + Quantum layer with a sequence of CX gates applied to three specified wires. + + This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) + tqf.cnot(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) + tqf.cnot(q_dev, wires=[2, 0], static=self.static_mode, parent_graph=self.graph) diff --git a/torchquantum/layer/layers/layers.py b/torchquantum/layer/layers/layers.py index 26433b66..d0672be5 100644 --- a/torchquantum/layer/layers/layers.py +++ b/torchquantum/layer/layers/layers.py @@ -34,14 +34,9 @@ from ..entanglement.op2_layer import Op2QAllLayer __all__ = [ + "SimpleQLayer", "LayerTemplate0", "Op1QAllLayer", - "layer_name_dict", - "CXLayer", - "CXCXCXLayer", - "SWAPSWAPLayer", - "RXYZCXLayer0", - "QFTLayer", ] @@ -73,72 +68,6 @@ def forward(self, q_dev): tqf.x(q_dev, wires=2, static=self.static_mode, parent_graph=self.graph) -class CXLayer(tq.QuantumModule): - """ - Quantum layer with a controlled-X (CX) gate applied to two specified wires. - - This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - - -class CXCXCXLayer(tq.QuantumModule): - """ - Quantum layer with a sequence of CX gates applied to three specified wires. - - This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - tqf.cnot(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) - tqf.cnot(q_dev, wires=[2, 0], static=self.static_mode, parent_graph=self.graph) - - -class SWAPSWAPLayer(tq.QuantumModule): - """ - Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. - - This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.swap(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - tqf.swap(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) - - class Op1QAllLayer(tq.QuantumModule): """ Quantum layer applying the same single-qubit operation to all wires. @@ -187,6 +116,8 @@ class LayerTemplate0(tq.QuantumModule): """ + name = None + def __init__(self, arch: dict = None): super().__init__() self.n_wires = arch["n_wires"] @@ -207,85 +138,6 @@ def forward(self, q_device: tq.QuantumDevice): self.layers_all[k](q_device) -class U3CU3Layer0(LayerTemplate0): - """ - Layer template with U3 and CU3 blocks. - - This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the U3 and CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.U3, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class CU3Layer0(LayerTemplate0): - """ - Layer template with CU3 blocks. - - This layer template consists of CU3 blocks repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=False, - ) - ) - return layers_all - - class CXRZSXLayer0(LayerTemplate0): """ Layer template with CXRZSX blocks. @@ -307,6 +159,8 @@ class CXRZSXLayer0(LayerTemplate0): """ + name = "cxrzsx_0" + def build_layers(self): layers_all = tq.QuantumModuleList() @@ -337,137 +191,6 @@ def build_layers(self): return layers_all -class SethLayer0(LayerTemplate0): - """ - Layer template with Seth blocks. - - This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class SethLayer1(LayerTemplate0): - """ - Layer template with extended Seth blocks. - - This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the extended Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class SethLayer2(LayerTemplate0): - """ - Layer template with Seth blocks using Op2QFit32Layer. - - This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Seth layers with Op2QFit32Layer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QFit32Layer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - class RZZLayer0(LayerTemplate0): """ Layer template with RZZ blocks. @@ -489,6 +212,8 @@ class RZZLayer0(LayerTemplate0): """ + name = "rzz_0" + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -526,6 +251,8 @@ class BarrenLayer0(LayerTemplate0): """ + name = "barren_0" + def build_layers(self): layers_all = tq.QuantumModuleList() layers_all.append( @@ -575,6 +302,8 @@ class FarhiLayer0(LayerTemplate0): """ + name = "farhi_0" + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -622,6 +351,8 @@ class MaxwellLayer0(LayerTemplate0): """ + name = "maxwell_0" + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -674,163 +405,6 @@ def build_layers(self): return layers_all -class RYRYCXLayer0(LayerTemplate0): - """ - Layer template with RYRYCX blocks. - - This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(CXLayer(n_wires=self.n_wires)) - return layers_all - - -class RYRYRYCXCXCXLayer0(LayerTemplate0): - """ - Layer template with RYRYRYCXCXCX blocks. - - This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(CXCXCXLayer(n_wires=self.n_wires)) - return layers_all - - -class RYRYRYLayer0(LayerTemplate0): - """ - Layer template with RYRYRYCXCXCX blocks. - - This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. - - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class RYRYRYSWAPSWAPLayer0(LayerTemplate0): - """ - Layer template with RYRYRYSWAPSWAP blocks. - - This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. - - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) - return layers_all - - -class SWAPSWAPLayer0(LayerTemplate0): - """ - Layer template with SWAPSWAP blocks. - - This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) - return layers_all - - class RXYZCXLayer0(LayerTemplate0): """ Layer template with RXYZCX blocks. @@ -851,6 +425,8 @@ class RXYZCXLayer0(LayerTemplate0): """ + name = "rxyzcx_0" + def build_layers(self): layers_all = tq.QuantumModuleList() for k in range(self.arch["n_blocks"]): @@ -873,130 +449,3 @@ def build_layers(self): Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) ) return layers_all - - -class QFTLayer(tq.QuantumModule): - def __init__( - self, - n_wires: int = None, - wires: Iterable = None, - do_swaps: bool = True, - inverse: bool = False, - ): - """ - Constructs a Quantum Fourier Transform (QFT) layer - - Args: - n_wires (int): Number of wires for the QFT as an integer - wires (Iterable): Wires to perform the QFT as an Iterable - do_swaps (bool): Whether or not to add the final swaps in a boolean format - inverse (bool): Whether to create an inverse QFT layer in a boolean format - """ - super().__init__() - - assert n_wires is not None or wires is not None - - if n_wires is None: - self.n_wires = len(wires) - - if wires is None: - wires = range(n_wires) - - self.n_wires = n_wires - self.wires = wires - self.do_swaps = do_swaps - - if inverse: - self.gates_all = self.build_inverse_circuit() - else: - self.gates_all = self.build_circuit() - - def build_circuit(self): - """Construct a QFT circuit.""" - - operation_list = [] - - # add the H and CU1 gates - for top_wire in range(self.n_wires): - operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) - for wire in range(top_wire + 1, self.n_wires): - lam = torch.pi / (2 ** (wire - top_wire)) - operation_list.append( - { - "name": "cu1", - "params": lam, - "wires": [self.wires[wire], self.wires[top_wire]], - } - ) - - # add swaps if specified - if self.do_swaps: - for wire in range(self.n_wires // 2): - operation_list.append( - { - "name": "swap", - "wires": [ - self.wires[wire], - self.wires[self.n_wires - wire - 1], - ], - } - ) - - return tq.QuantumModule.from_op_history(operation_list) - - def build_inverse_circuit(self): - """Construct the inverse of a QFT circuit.""" - - operation_list = [] - - # add swaps if specified - if self.do_swaps: - for wire in range(self.n_wires // 2): - operation_list.append( - { - "name": "swap", - "wires": [ - self.wires[wire], - self.wires[self.n_wires - wire - 1], - ], - } - ) - - # add the CU1 and H gates - for top_wire in range(self.n_wires)[::-1]: - for wire in range(top_wire + 1, self.n_wires)[::-1]: - lam = -torch.pi / (2 ** (wire - top_wire)) - operation_list.append( - { - "name": "cu1", - "params": lam, - "wires": [self.wires[wire], self.wires[top_wire]], - } - ) - operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) - - return tq.QuantumModule.from_op_history(operation_list) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - self.gates_all(q_device) - - -layer_name_dict = { - "u3cu3_0": U3CU3Layer0, - "cu3_0": CU3Layer0, - "cxrzsx_0": CXRZSXLayer0, - "seth_0": SethLayer0, - "seth_1": SethLayer1, - "seth_2": SethLayer2, - "rzz_0": RZZLayer0, - "barren_0": BarrenLayer0, - "farhi_0": FarhiLayer0, - "maxwell_0": MaxwellLayer0, - "ryrycx": RYRYCXLayer0, - "ryryrycxcxcx": RYRYRYCXCXCXLayer0, - "ryryry": RYRYRYLayer0, - "swapswap": SWAPSWAPLayer0, - "ryryryswapswap": RYRYRYSWAPSWAPLayer0, - "rxyzcx_0": RXYZCXLayer0, -} diff --git a/torchquantum/layer/layers/qft_layer.py b/torchquantum/layer/layers/qft_layer.py new file mode 100644 index 00000000..f782cfef --- /dev/null +++ b/torchquantum/layer/layers/qft_layer.py @@ -0,0 +1,117 @@ +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger +from ..entanglement.op2_layer import Op2QAllLayer + + +class QFTLayer(tq.QuantumModule): + def __init__( + self, + n_wires: int = None, + wires: Iterable = None, + do_swaps: bool = True, + inverse: bool = False, + ): + """ + Constructs a Quantum Fourier Transform (QFT) layer + + Args: + n_wires (int): Number of wires for the QFT as an integer + wires (Iterable): Wires to perform the QFT as an Iterable + do_swaps (bool): Whether or not to add the final swaps in a boolean format + inverse (bool): Whether to create an inverse QFT layer in a boolean format + """ + super().__init__() + + assert n_wires is not None or wires is not None + + if n_wires is None: + self.n_wires = len(wires) + + if wires is None: + wires = range(n_wires) + + self.n_wires = n_wires + self.wires = wires + self.do_swaps = do_swaps + + if inverse: + self.gates_all = self.build_inverse_circuit() + else: + self.gates_all = self.build_circuit() + + def build_circuit(self): + """Construct a QFT circuit.""" + + operation_list = [] + + # add the H and CU1 gates + for top_wire in range(self.n_wires): + operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) + for wire in range(top_wire + 1, self.n_wires): + lam = torch.pi / (2 ** (wire - top_wire)) + operation_list.append( + { + "name": "cu1", + "params": lam, + "wires": [self.wires[wire], self.wires[top_wire]], + } + ) + + # add swaps if specified + if self.do_swaps: + for wire in range(self.n_wires // 2): + operation_list.append( + { + "name": "swap", + "wires": [ + self.wires[wire], + self.wires[self.n_wires - wire - 1], + ], + } + ) + + return tq.QuantumModule.from_op_history(operation_list) + + def build_inverse_circuit(self): + """Construct the inverse of a QFT circuit.""" + + operation_list = [] + + # add swaps if specified + if self.do_swaps: + for wire in range(self.n_wires // 2): + operation_list.append( + { + "name": "swap", + "wires": [ + self.wires[wire], + self.wires[self.n_wires - wire - 1], + ], + } + ) + + # add the CU1 and H gates + for top_wire in range(self.n_wires)[::-1]: + for wire in range(top_wire + 1, self.n_wires)[::-1]: + lam = -torch.pi / (2 ** (wire - top_wire)) + operation_list.append( + { + "name": "cu1", + "params": lam, + "wires": [self.wires[wire], self.wires[top_wire]], + } + ) + operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) + + return tq.QuantumModule.from_op_history(operation_list) + + @tq.static_support + def forward(self, q_device: tq.QuantumDevice): + self.gates_all(q_device) diff --git a/torchquantum/layer/layers/ry_layer.py b/torchquantum/layer/layers/ry_layer.py new file mode 100644 index 00000000..54e0110a --- /dev/null +++ b/torchquantum/layer/layers/ry_layer.py @@ -0,0 +1,150 @@ +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger +from ..entanglement.op2_layer import Op2QAllLayer + +from .layers import LayerTemplate0 + + +class RYRYCXLayer0(LayerTemplate0): + """ + Layer template with RYRYCX blocks. + + This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + name = "ryrycx" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(CXLayer(n_wires=self.n_wires)) + return layers_all + + +class RYRYRYCXCXCXLayer0(LayerTemplate0): + """ + Layer template with RYRYRYCXCXCX blocks. + + This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. + + """ + + name = "ryryrycxcxcx" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(CXCXCXLayer(n_wires=self.n_wires)) + return layers_all + + +class RYRYRYLayer0(LayerTemplate0): + """ + Layer template with RYRYRYCXCXCX blocks. + + This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. + + + """ + + name = "ryryry" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + return layers_all + + +class RYRYRYSWAPSWAPLayer0(LayerTemplate0): + """ + Layer template with RYRYRYSWAPSWAP blocks. + + This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. + + + """ + + name = "ryryryswapswap" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) + return layers_all diff --git a/torchquantum/layer/layers/seth_layer.py b/torchquantum/layer/layers/seth_layer.py new file mode 100644 index 00000000..c80d095e --- /dev/null +++ b/torchquantum/layer/layers/seth_layer.py @@ -0,0 +1,172 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +from .layers import LayerTemplate0 + + +class SethLayer0(LayerTemplate0): + """ + Layer template with Seth blocks. + + This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + name = "seth_0" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + return layers_all + + +class SethLayer1(LayerTemplate0): + """ + Layer template with extended Seth blocks. + + This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the extended Seth layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + name = "seth_1" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + layers_all.append( + Op1QAllLayer( + op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class SethLayer2(LayerTemplate0): + """ + Layer template with Seth blocks using Op2QFit32Layer. + + This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the Seth layers with Op2QFit32Layer for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + name = "seth_2" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QFit32Layer( + op=tq.RZZ, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all diff --git a/torchquantum/layer/layers/swap_layer.py b/torchquantum/layer/layers/swap_layer.py new file mode 100644 index 00000000..65adf15f --- /dev/null +++ b/torchquantum/layer/layers/swap_layer.py @@ -0,0 +1,86 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +from .layers import LayerTemplate0 + + +class SWAPSWAPLayer(tq.QuantumModule): + """ + Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. + + This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. + + Args: + n_wires (int): Number of wires in the quantum device. + + """ + + def __init__(self, n_wires): + super().__init__() + self.n_wires = n_wires + + @tq.static_support + def forward(self, q_dev): + self.q_device = q_dev + tqf.swap(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) + tqf.swap(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) + + +class SWAPSWAPLayer0(LayerTemplate0): + """ + Layer template with SWAPSWAP blocks. + + This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. + + """ + + name = "swapswap" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) + return layers_all diff --git a/torchquantum/layer/layers/u3_layer.py b/torchquantum/layer/layers/u3_layer.py new file mode 100644 index 00000000..b46d8b45 --- /dev/null +++ b/torchquantum/layer/layers/u3_layer.py @@ -0,0 +1,118 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import torchquantum as tq +import torchquantum.functional as tqf +import numpy as np + +from typing import Iterable +from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES +from torchpack.utils.logging import logger + +from .layers import LayerTemplate0 + + +class U3CU3Layer0(LayerTemplate0): + """ + Layer template with U3 and CU3 blocks. + + This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the U3 and CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + name = "u3cu3_0" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op1QAllLayer( + op=tq.U3, n_wires=self.n_wires, has_params=True, trainable=True + ) + ) + layers_all.append( + Op2QAllLayer( + op=tq.CU3, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=True, + ) + ) + return layers_all + + +class CU3Layer0(LayerTemplate0): + """ + Layer template with CU3 blocks. + + This layer template consists of CU3 blocks repeated for the specified number of blocks. + + Args: + arch (dict, optional): The architecture configuration for the layer. Defaults to None. + + Attributes: + n_wires (int): The number of wires in the layer. + arch (dict): The architecture configuration for the layer. + n_blocks (int): The number of blocks in the layer. + layers_all (tq.QuantumModuleList): The list of layers in the template. + + Methods: + build_layers: Builds the CU3 layers for the template. + forward: Applies the quantum layer to the given quantum device. + + """ + + name = "cu3_0" + + def build_layers(self): + layers_all = tq.QuantumModuleList() + for k in range(self.arch["n_blocks"]): + layers_all.append( + Op2QAllLayer( + op=tq.CU3, + n_wires=self.n_wires, + has_params=True, + trainable=True, + jump=1, + circular=False, + ) + ) + return layers_all diff --git a/torchquantum/layer/nlocal/nlocal.py b/torchquantum/layer/nlocal/nlocal.py index 16e3d378..9b358c3b 100644 --- a/torchquantum/layer/nlocal/nlocal.py +++ b/torchquantum/layer/nlocal/nlocal.py @@ -26,8 +26,8 @@ from torchquantum.layer.layers import ( LayerTemplate0, Op1QAllLayer, - Op2QAllLayer, ) +from torchquantum.layer.entanglement import Op2QAllLayer __all__ = [ "NLocal", diff --git a/torchquantum/layer/nlocal/two_local.py b/torchquantum/layer/nlocal/two_local.py index 2df63806..ac81d741 100644 --- a/torchquantum/layer/nlocal/two_local.py +++ b/torchquantum/layer/nlocal/two_local.py @@ -25,6 +25,8 @@ import torchquantum as tq from torchquantum.layer.layers import ( Op1QAllLayer, +) +from torchquantum.layer.entanglement import ( Op2QAllLayer, Op2QDenseLayer, ) From 8aa995a5618aaa432f2c0abcde91767eba8ecea8 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 23 Dec 2023 16:11:48 -0600 Subject: [PATCH 063/106] [minor] add full entanglement path --- torchquantum/layer/layers/layers.py | 2 +- torchquantum/layer/layers/qft_layer.py | 2 -- torchquantum/layer/layers/ry_layer.py | 1 - 3 files changed, 1 insertion(+), 4 deletions(-) diff --git a/torchquantum/layer/layers/layers.py b/torchquantum/layer/layers/layers.py index d0672be5..024a5316 100644 --- a/torchquantum/layer/layers/layers.py +++ b/torchquantum/layer/layers/layers.py @@ -31,7 +31,7 @@ from typing import Iterable from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES from torchpack.utils.logging import logger -from ..entanglement.op2_layer import Op2QAllLayer +from torchquantum.layer.entanglement.op2_layer import Op2QAllLayer __all__ = [ "SimpleQLayer", diff --git a/torchquantum/layer/layers/qft_layer.py b/torchquantum/layer/layers/qft_layer.py index f782cfef..6ab1539e 100644 --- a/torchquantum/layer/layers/qft_layer.py +++ b/torchquantum/layer/layers/qft_layer.py @@ -7,8 +7,6 @@ from typing import Iterable from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES from torchpack.utils.logging import logger -from ..entanglement.op2_layer import Op2QAllLayer - class QFTLayer(tq.QuantumModule): def __init__( diff --git a/torchquantum/layer/layers/ry_layer.py b/torchquantum/layer/layers/ry_layer.py index 54e0110a..198d3dc5 100644 --- a/torchquantum/layer/layers/ry_layer.py +++ b/torchquantum/layer/layers/ry_layer.py @@ -7,7 +7,6 @@ from typing import Iterable from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES from torchpack.utils.logging import logger -from ..entanglement.op2_layer import Op2QAllLayer from .layers import LayerTemplate0 From 4bd7e7c1f055ca79bc247f7e2ce88ae3a9b5f47f Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 24 Dec 2023 15:43:01 -0600 Subject: [PATCH 064/106] [minor] added parameters for quanvolution and qlstm --- .github/workflows/functional_tests.yaml | 2 + examples/quantum_lstm/qlstm.py | 22 ++++++--- examples/quanvolution/quanvolution.py | 59 +++++++++++++++---------- 3 files changed, 54 insertions(+), 29 deletions(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 334d32cf..f48522cc 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -59,3 +59,5 @@ jobs: python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 python3 examples/grover/grover_example_sudoku.py python3 examples/param_shift_onchip_training/param_shift.py + python3 examples/python3 quanvolution.py --epochs 1 + python3 examples/quantum_lstm/qlstm.py --epochs 1 diff --git a/examples/quantum_lstm/qlstm.py b/examples/quantum_lstm/qlstm.py index b2f3e32f..82c9258b 100644 --- a/examples/quantum_lstm/qlstm.py +++ b/examples/quantum_lstm/qlstm.py @@ -31,6 +31,7 @@ import torch.nn as nn import torchquantum as tq import torchquantum.functional as tqf +import argparse class QLSTM(nn.Module): @@ -358,6 +359,19 @@ def plot_history(history_classical, history_quantum): plt.show() def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument("--display", action="store_true", help="display results with matplotlib") + parser.add_argument( + "--epochs", type=int, default=300, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + tag_to_ix = {"DET": 0, "NN": 1, "V": 2} # Assign each tag with a unique index ix_to_tag = {i:k for k,i in tag_to_ix.items()} @@ -380,7 +394,7 @@ def main(): embedding_dim = 8 hidden_dim = 6 - n_epochs = 300 + n_epochs = args.epochs model_classical = LSTMTagger(embedding_dim, hidden_dim, @@ -404,10 +418,8 @@ def main(): print_result(model_quantum, training_data, word_to_ix, ix_to_tag) - plot_history(history_classical, history_quantum) + if args.display: + plot_history(history_classical, history_quantum) if __name__ == "__main__": - import pdb - pdb.set_trace() - main() diff --git a/examples/quanvolution/quanvolution.py b/examples/quanvolution/quanvolution.py index ada4561b..28ee592b 100644 --- a/examples/quanvolution/quanvolution.py +++ b/examples/quanvolution/quanvolution.py @@ -30,6 +30,7 @@ import torch.optim as optim import numpy as np import random +import argparse from torchquantum.dataset import MNIST from torch.optim.lr_scheduler import CosineAnnealingLR @@ -150,8 +151,17 @@ def valid_test(dataflow, split, model, device, qiskit=False): def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--epochs", type=int, default=15, help="number of training epochs" + ) + parser.add_argument( + "--qiskit-simulation", action="store_true", help="run the program on a real quantum computer" + ) + args = parser.parse_args() + train_model_without_qf = True - n_epochs = 15 + n_epochs = args.epochs random.seed(42) np.random.seed(42) @@ -220,29 +230,30 @@ def main(): scheduler.step() - # run on real QC - try: - from qiskit import IBMQ - from torchquantum.plugin import QiskitProcessor - - # firstly perform simulate - print(f"\nTest with Qiskit Simulator") - processor_simulation = QiskitProcessor(use_real_qc=False) - model.qf.set_qiskit_processor(processor_simulation) - valid_test(dataflow, "test", model, device, qiskit=True) - # then try to run on REAL QC - backend_name = "ibmq_quito" - print(f"\nTest on Real Quantum Computer {backend_name}") - processor_real_qc = QiskitProcessor(use_real_qc=True, backend_name=backend_name) - model.qf.set_qiskit_processor(processor_real_qc) - valid_test(dataflow, "test", model, device, qiskit=True) - except ImportError: - print( - "Please install qiskit, create an IBM Q Experience Account and " - "save the account token according to the instruction at " - "'https://github.com/Qiskit/qiskit-ibmq-provider', " - "then try again." - ) + if args.qiskit_simulation: + # run on real QC + try: + from qiskit import IBMQ + from torchquantum.plugin import QiskitProcessor + + # firstly perform simulate + print(f"\nTest with Qiskit Simulator") + processor_simulation = QiskitProcessor(use_real_qc=False) + model.qf.set_qiskit_processor(processor_simulation) + valid_test(dataflow, "test", model, device, qiskit=True) + # then try to run on REAL QC + backend_name = "ibmq_quito" + print(f"\nTest on Real Quantum Computer {backend_name}") + processor_real_qc = QiskitProcessor(use_real_qc=True, backend_name=backend_name) + model.qf.set_qiskit_processor(processor_real_qc) + valid_test(dataflow, "test", model, device, qiskit=True) + except ImportError: + print( + "Please install qiskit, create an IBM Q Experience Account and " + "save the account token according to the instruction at " + "'https://github.com/Qiskit/qiskit-ibmq-provider', " + "then try again." + ) if __name__ == "__main__": From e4ad65d72a1aa9fd793019627ff497688977b183 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 24 Dec 2023 15:57:30 -0600 Subject: [PATCH 065/106] [minor] update typo --- .github/workflows/functional_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index f48522cc..10a5d030 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -59,5 +59,5 @@ jobs: python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 python3 examples/grover/grover_example_sudoku.py python3 examples/param_shift_onchip_training/param_shift.py - python3 examples/python3 quanvolution.py --epochs 1 + python3 examples/quanvolution/quanvolution.py --epochs 1 python3 examples/quantum_lstm/qlstm.py --epochs 1 From 64f8d20f6eedc932376d018562bfe0bccd492358 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 24 Dec 2023 22:50:33 -0600 Subject: [PATCH 066/106] [minor] add tests for optimal_control, qaoa, mnist --- .github/workflows/functional_tests.yaml | 6 ++ examples/mnist/mnist.py | 66 ++++++++++--------- examples/optimal_control/optimal_control.py | 17 ++++- .../optimal_control_gaussian.py | 17 ++++- .../optimal_control_multi_qubit.py | 17 ++++- examples/qaoa/max_cut_backprop.py | 9 ++- 6 files changed, 90 insertions(+), 42 deletions(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 10a5d030..f234d0b0 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -61,3 +61,9 @@ jobs: python3 examples/param_shift_onchip_training/param_shift.py python3 examples/quanvolution/quanvolution.py --epochs 1 python3 examples/quantum_lstm/qlstm.py --epochs 1 + python3 examples/qaoa/max_cut_backprop.py --steps 1 + python3 examples/optimal_control/optimal_control.py --epochs 1 + python3 examples/optimal_control/optimal_control_gaussian.py --epochs 1 + python3 examples/optimal_control/optimal_control_multi_qubit.py --epochs 1 + python3 examples/save_load_example/save_load.py + python3 examples/mnist/mnist.py --epochs 1 diff --git a/examples/mnist/mnist.py b/examples/mnist/mnist.py index 23e5eafe..d8b32e25 100644 --- a/examples/mnist/mnist.py +++ b/examples/mnist/mnist.py @@ -179,6 +179,7 @@ def main(): "--static", action="store_true", help="compute with " "static mode" ) parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument("--qiskit-simulation", action="store_true", help="run on a real quantum computer") parser.add_argument( "--wires-per-block", type=int, default=2, help="wires per block int static mode" ) @@ -243,38 +244,39 @@ def main(): # test valid_test(dataflow, "test", model, device, qiskit=False) - # run on Qiskit simulator and real Quantum Computers - try: - from qiskit import IBMQ - from torchquantum.plugin import QiskitProcessor - - # firstly perform simulate - print(f"\nTest with Qiskit Simulator") - processor_simulation = QiskitProcessor(use_real_qc=False) - model.set_qiskit_processor(processor_simulation) - valid_test(dataflow, "test", model, device, qiskit=True) - - # then try to run on REAL QC - backend_name = "ibmq_lima" - print(f"\nTest on Real Quantum Computer {backend_name}") - # Please specify your own hub group and project if you have the - # IBMQ premium plan to access more machines. - processor_real_qc = QiskitProcessor( - use_real_qc=True, - backend_name=backend_name, - hub="ibm-q", - group="open", - project="main", - ) - model.set_qiskit_processor(processor_real_qc) - valid_test(dataflow, "test", model, device, qiskit=True) - except ImportError: - print( - "Please install qiskit, create an IBM Q Experience Account and " - "save the account token according to the instruction at " - "'https://github.com/Qiskit/qiskit-ibmq-provider', " - "then try again." - ) + if args.qiskit_simulation: + # run on Qiskit simulator and real Quantum Computers + try: + from qiskit import IBMQ + from torchquantum.plugin import QiskitProcessor + + # firstly perform simulate + print(f"\nTest with Qiskit Simulator") + processor_simulation = QiskitProcessor(use_real_qc=False) + model.set_qiskit_processor(processor_simulation) + valid_test(dataflow, "test", model, device, qiskit=True) + + # then try to run on REAL QC + backend_name = "ibmq_lima" + print(f"\nTest on Real Quantum Computer {backend_name}") + # Please specify your own hub group and project if you have the + # IBMQ premium plan to access more machines. + processor_real_qc = QiskitProcessor( + use_real_qc=True, + backend_name=backend_name, + hub="ibm-q", + group="open", + project="main", + ) + model.set_qiskit_processor(processor_real_qc) + valid_test(dataflow, "test", model, device, qiskit=True) + except ImportError: + print( + "Please install qiskit, create an IBM Q Experience Account and " + "save the account token according to the instruction at " + "'https://github.com/Qiskit/qiskit-ibmq-provider', " + "then try again." + ) if __name__ == "__main__": diff --git a/examples/optimal_control/optimal_control.py b/examples/optimal_control/optimal_control.py index 89601153..2bff28c4 100644 --- a/examples/optimal_control/optimal_control.py +++ b/examples/optimal_control/optimal_control.py @@ -26,11 +26,22 @@ import torch.optim as optim import torchquantum as tq -import pdb +import argparse import numpy as np if __name__ == "__main__": - pdb.set_trace() + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument( + "--epochs", type=int, default=1000, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + # target_unitary = torch.tensor([[0, 1], [1, 0]], dtype=torch.complex64) theta = 0.6 target_unitary = torch.tensor( @@ -45,7 +56,7 @@ optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) - for k in range(1000): + for k in range(args.epochs): # loss = (abs(pulse.get_unitary() - target_unitary)**2).sum() loss = ( 1 diff --git a/examples/optimal_control/optimal_control_gaussian.py b/examples/optimal_control/optimal_control_gaussian.py index 559e6127..51192173 100644 --- a/examples/optimal_control/optimal_control_gaussian.py +++ b/examples/optimal_control/optimal_control_gaussian.py @@ -26,11 +26,22 @@ import torch.optim as optim import torchquantum as tq -import pdb +import argparse import numpy as np if __name__ == "__main__": - pdb.set_trace() + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument( + "--epochs", type=int, default=1000, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + # target_unitary = torch.tensor([[0, 1], [1, 0]], dtype=torch.complex64) theta = 1.1 target_unitary = torch.tensor( @@ -45,7 +56,7 @@ optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) - for k in range(1000): + for k in range(args.epochs): # loss = (abs(pulse.get_unitary() - target_unitary)**2).sum() loss = ( 1 diff --git a/examples/optimal_control/optimal_control_multi_qubit.py b/examples/optimal_control/optimal_control_multi_qubit.py index 148b526c..5658f269 100644 --- a/examples/optimal_control/optimal_control_multi_qubit.py +++ b/examples/optimal_control/optimal_control_multi_qubit.py @@ -26,11 +26,22 @@ import torch.optim as optim import torchquantum as tq -import pdb +import argparse import numpy as np if __name__ == "__main__": - pdb.set_trace() + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument( + "--epochs", type=int, default=1000, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + # target_unitary = torch.tensor([[0, 1], [1, 0]], dtype=torch.complex64) theta = 0.6 target_unitary = torch.tensor( @@ -62,7 +73,7 @@ lr=5e-3, ) - for k in range(1000): + for k in range(args.epochs): u_0 = pulse_q0.get_unitary() u_1 = pulse_q1.get_unitary() u_01 = pulse_q01.get_unitary() diff --git a/examples/qaoa/max_cut_backprop.py b/examples/qaoa/max_cut_backprop.py index 803d16c9..2f9b2210 100644 --- a/examples/qaoa/max_cut_backprop.py +++ b/examples/qaoa/max_cut_backprop.py @@ -27,6 +27,7 @@ import random import numpy as np +import argparse from torchquantum.functional import mat_dict @@ -172,6 +173,12 @@ def backprop_optimize(model, n_steps=100, lr=0.1): def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--steps", type=int, default=300, help="number of steps" + ) + args = parser.parse_args() + # create a input_graph input_graph = [(0, 1), (0, 3), (1, 2), (2, 3)] n_wires = 4 @@ -184,7 +191,7 @@ def main(): # print("The circuit is", circ.draw(output="mpl")) # circ.draw(output="mpl") # use backprop - backprop_optimize(model, n_steps=300, lr=0.01) + backprop_optimize(model, n_steps=args.steps, lr=0.01) # use parameter shift rule # param_shift_optimize(model, n_steps=500, step_size=100000) From cd0cff62dbd39cf18d63f574bab3a482aacaf39e Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 29 Dec 2023 15:47:09 -0600 Subject: [PATCH 067/106] [major] reformatting functionals --- torchquantum/functional/__init__.py | 195 +- torchquantum/functional/ecr.py | 74 + .../functional/func_controlled_unitary.py | 19 +- torchquantum/functional/func_mat_exp.py | 5 +- torchquantum/functional/functionals.py | 4329 ----------------- torchquantum/functional/gate_wrapper.py | 3 - torchquantum/functional/global_phase.py | 80 + torchquantum/functional/hadamard.py | 88 +- torchquantum/functional/i.py | 67 + torchquantum/functional/paulix.py | 617 +++ torchquantum/functional/pauliy.py | 120 + torchquantum/functional/pauliz.py | 180 + torchquantum/functional/phase_shift.py | 99 + torchquantum/functional/qft.py | 68 + torchquantum/functional/qubit_unitary.py | 234 + torchquantum/functional/r.py | 105 + torchquantum/functional/reset.py | 42 + torchquantum/functional/rot.py | 189 + torchquantum/functional/rx.py | 266 + torchquantum/functional/ry.py | 255 + torchquantum/functional/rz.py | 419 ++ torchquantum/functional/s.py | 218 + torchquantum/functional/single_excitation.py | 100 + torchquantum/functional/swap.py | 236 + torchquantum/functional/sx.py | 235 + torchquantum/functional/t.py | 116 + torchquantum/functional/u1.py | 177 + torchquantum/functional/u2.py | 171 + torchquantum/functional/u3.py | 260 + torchquantum/functional/xx_min_yy.py | 127 + torchquantum/functional/xx_plus_yy.py | 127 + torchquantum/operator/standard_gates/ecr.py | 2 +- .../operator/standard_gates/global_phase.py | 2 +- .../operator/standard_gates/hadamard.py | 2 +- torchquantum/operator/standard_gates/i.py | 2 +- torchquantum/operator/standard_gates/iswap.py | 2 +- .../operator/standard_gates/paulix.py | 2 +- .../operator/standard_gates/pauliy.py | 2 +- .../operator/standard_gates/pauliz.py | 2 +- .../operator/standard_gates/phase_shift.py | 2 +- torchquantum/operator/standard_gates/qft.py | 3 +- .../operator/standard_gates/qubit_unitary.py | 2 +- torchquantum/operator/standard_gates/r.py | 2 +- torchquantum/operator/standard_gates/reset.py | 2 +- torchquantum/operator/standard_gates/rot.py | 2 +- torchquantum/operator/standard_gates/rx.py | 2 +- torchquantum/operator/standard_gates/ry.py | 2 +- torchquantum/operator/standard_gates/rz.py | 2 +- torchquantum/operator/standard_gates/s.py | 2 +- .../standard_gates/single_excitation.py | 2 +- torchquantum/operator/standard_gates/swap.py | 2 +- torchquantum/operator/standard_gates/sx.py | 2 +- torchquantum/operator/standard_gates/t.py | 2 +- .../operator/standard_gates/toffoli.py | 2 +- .../standard_gates/trainable_unitary.py | 2 +- torchquantum/operator/standard_gates/u1.py | 2 +- torchquantum/operator/standard_gates/u2.py | 2 +- torchquantum/operator/standard_gates/u3.py | 2 +- .../operator/standard_gates/xx_min_yy.py | 2 +- .../operator/standard_gates/xx_plus_yy.py | 2 +- 60 files changed, 4889 insertions(+), 4391 deletions(-) create mode 100644 torchquantum/functional/ecr.py create mode 100644 torchquantum/functional/global_phase.py create mode 100644 torchquantum/functional/i.py create mode 100644 torchquantum/functional/paulix.py create mode 100644 torchquantum/functional/pauliy.py create mode 100644 torchquantum/functional/pauliz.py create mode 100644 torchquantum/functional/phase_shift.py create mode 100644 torchquantum/functional/qft.py create mode 100644 torchquantum/functional/qubit_unitary.py create mode 100644 torchquantum/functional/r.py create mode 100644 torchquantum/functional/reset.py create mode 100644 torchquantum/functional/rot.py create mode 100644 torchquantum/functional/rx.py create mode 100644 torchquantum/functional/ry.py create mode 100644 torchquantum/functional/rz.py create mode 100644 torchquantum/functional/s.py create mode 100644 torchquantum/functional/single_excitation.py create mode 100644 torchquantum/functional/swap.py create mode 100644 torchquantum/functional/sx.py create mode 100644 torchquantum/functional/t.py create mode 100644 torchquantum/functional/u1.py create mode 100644 torchquantum/functional/u2.py create mode 100644 torchquantum/functional/u3.py create mode 100644 torchquantum/functional/xx_min_yy.py create mode 100644 torchquantum/functional/xx_plus_yy.py diff --git a/torchquantum/functional/__init__.py b/torchquantum/functional/__init__.py index aefad506..f17b9cc1 100644 --- a/torchquantum/functional/__init__.py +++ b/torchquantum/functional/__init__.py @@ -22,12 +22,197 @@ SOFTWARE. """ -from .functionals import * +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm +from .hadamard import hadamard, shadamard, _hadamard_mat_dict, h, ch, sh, chadamard +from .rx import rx, rxx, crx, xx, _rx_mat_dict, rx_matrix, rxx_matrix, crx_matrix +from .ry import ry, ryy, cry, yy, _ry_mat_dict, ry_matrix, ryy_matrix, cry_matrix +from .rz import ( + rz, + rzz, + crz, + zz, + zx, + multirz, + rzx, + _rz_mat_dict, + rz_matrix, + rzz_matrix, + crz_matrix, + multirz_matrix, + rzx_matrix, +) +from .phase_shift import phaseshift_matrix, phaseshift, p, _phaseshift_mat_dict +from .rot import rot, crot, rot_matrix, crot_matrix, _rot_mat_dict +from .reset import reset +from .xx_min_yy import xxminyy, xxminyy_matrix, _xxminyy_mat_dict +from .xx_plus_yy import xxplusyy, xxplusyy_matrix, _xxplusyy_mat_dict +from .u1 import u1, cu1, u1_matrix, cu1_matrix, _u1_mat_dict, cp, cr, cphase +from .u2 import u2, cu2, u2_matrix, cu2_matrix, _u2_mat_dict +from .u3 import u, u3, cu3, cu, cu_matrix, u3_matrix, cu3_matrix, _u3_mat_dict +from .qubit_unitary import ( + qubitunitary, + qubitunitaryfast, + qubitunitarystrict, + qubitunitary_matrix, + qubitunitaryfast_matrix, + qubitunitarystrict_matrix, + _qubitunitary_mat_dict, +) +from .single_excitation import ( + singleexcitation, + singleexcitation_matrix, + _singleexcitation_mat_dict, +) +from .paulix import ( + _x_mat_dict, + multicnot_matrix, + multixcnot_matrix, + paulix, + cnot, + multicnot, + multixcnot, + x, + c3x, + c4x, + dcx, + toffoli, + ccnot, + ccx, + cx, + rccx, + rc3x, +) +from .pauliy import _y_mat_dict, pauliy, cy, y +from .pauliz import _z_mat_dict, pauliz, cz, ccz, z +from .qft import _qft_mat_dict, qft, qft_matrix +from .r import _r_mat_dict, r, r_matrix +from .global_phase import _globalphase_mat_dict, globalphase, globalphase_matrix +from .sx import _sx_mat_dict, sx, c3sx, sxdg, csx +from .i import _i_mat_dict, i +from .s import _s_mat_dict, s, sdg, cs, csdg +from .t import _t_mat_dict, t, tdg +from .swap import _swap_mat_dict, swap, sswap, iswap, cswap +from .ecr import _ecr_mat_dict, ecr, echoedcrossresonance -from .func_mat_exp import * -from .func_controlled_unitary import * +mat_dict = { + **_hadamard_mat_dict, + **_rx_mat_dict, + **_ry_mat_dict, + **_rz_mat_dict, + **_phaseshift_mat_dict, + **_rot_mat_dict, + **_xxminyy_mat_dict, + **_xxplusyy_mat_dict, + **_u1_mat_dict, + **_u2_mat_dict, + **_u3_mat_dict, + **_qubitunitary_mat_dict, + **_x_mat_dict, + **_y_mat_dict, + **_z_mat_dict, + **_singleexcitation_mat_dict, + **_qft_mat_dict, + **_r_mat_dict, + **_globalphase_mat_dict, + **_sx_mat_dict, + **_i_mat_dict, + **_s_mat_dict, + **_t_mat_dict, + **_swap_mat_dict, + **_ecr_mat_dict, +} + +func_name_dict = { + "hadamard": hadamard, + "h": h, + "sh": shadamard, + "paulix": paulix, + "pauliy": pauliy, + "pauliz": pauliz, + "i": i, + "s": s, + "t": t, + "sx": sx, + "cnot": cnot, + "cz": cz, + "cy": cy, + "rx": rx, + "ry": ry, + "rz": rz, + "rxx": rxx, + "xx": xx, + "ryy": ryy, + "yy": yy, + "rzz": rzz, + "zz": zz, + "rzx": rzx, + "zx": zx, + "swap": swap, + "sswap": sswap, + "cswap": cswap, + "toffoli": toffoli, + "phaseshift": phaseshift, + "p": p, + "cp": cp, + "rot": rot, + "multirz": multirz, + "crx": crx, + "cry": cry, + "crz": crz, + "crot": crot, + "u1": u1, + "u2": u2, + "u3": u3, + "u": u, + "cu1": cu1, + "cphase": cphase, + "cr": cr, + "cu2": cu2, + "cu3": cu3, + "cu": cu, + "qubitunitary": qubitunitary, + "qubitunitaryfast": qubitunitaryfast, + "qubitunitarystrict": qubitunitarystrict, + "multicnot": multicnot, + "multixcnot": multixcnot, + "x": x, + "y": y, + "z": z, + "cx": cx, + "ccnot": ccnot, + "ccx": ccx, + "reset": reset, + "singleexcitation": singleexcitation, + "ecr": ecr, + "echoedcrossresonance": echoedcrossresonance, + "qft": qft, + "sdg": sdg, + "tdg": tdg, + "sxdg": sxdg, + "ch": ch, + "ccz": ccz, + "iswap": iswap, + "cs": cs, + "csdg": csdg, + "csx": csx, + "chadamard": chadamard, + "ccz": ccz, + "dcx": dcx, + "xxminyy": xxminyy, + "xxplusyy": xxplusyy, + "c3x": c3x, + "r": r, + "globalphase": globalphase, + "c3sx": c3sx, + "rccx": rccx, + "rc3x": rc3x, + "c4x": c4x, +} + +from .func_mat_exp import matrix_exp +from .func_controlled_unitary import controlled_unitary func_name_dict_collect = { - 'matrix_exp': matrix_exp, - 'controlled_unitary': controlled_unitary, + "matrix_exp": matrix_exp, + "controlled_unitary": controlled_unitary, } diff --git a/torchquantum/functional/ecr.py b/torchquantum/functional/ecr.py new file mode 100644 index 00000000..ade7606c --- /dev/null +++ b/torchquantum/functional/ecr.py @@ -0,0 +1,74 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + +_ecr_mat_dict = { + "ecr": INV_SQRT2 + * torch.tensor( + [[0, 0, 1, 1j], [0, 0, 1j, 1], [1, -1j, 0, 0], [-1j, 1, 0, 0]], dtype=C_DTYPE + ), +} + + +def ecr( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the echoed cross-resonance gate. + https://qiskit.org/documentation/stubs/qiskit.circuit.library.ECRGate.html + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "ecr" + mat = _ecr_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +echoedcrossresonance = ecr diff --git a/torchquantum/functional/func_controlled_unitary.py b/torchquantum/functional/func_controlled_unitary.py index 6d476fc3..dc909815 100644 --- a/torchquantum/functional/func_controlled_unitary.py +++ b/torchquantum/functional/func_controlled_unitary.py @@ -24,9 +24,10 @@ import numpy as np import torch -from torchquantum.functional.functionals import gate_wrapper +from torchquantum.functional.gate_wrapper import gate_wrapper from torchquantum.macro import * + def controlled_unitary( qdev, c_wires, @@ -41,7 +42,7 @@ def controlled_unitary( t_wires: can be a list of list of wires, multiple sets [[1,2], [3,4]] params: the parameters of the unitary - + Returns: None. @@ -113,19 +114,19 @@ def controlled_unitary( unitary[-d_controlled_u:, -d_controlled_u:] = controlled_u # return cls( - # has_params=True, - # trainable=trainable, - # init_params=unitary, - # n_wires=n_wires, - # wires=wires, + # has_params=True, + # trainable=trainable, + # init_params=unitary, + # n_wires=n_wires, + # wires=wires, # ) - name = 'qubitunitaryfast' + name = "qubitunitaryfast" unitary = unitary.to(qdev.device) gate_wrapper( name=name, mat=unitary, - method='bmm', + method="bmm", q_device=qdev, wires=wires, n_wires=n_wires, diff --git a/torchquantum/functional/func_mat_exp.py b/torchquantum/functional/func_mat_exp.py index d8f603e4..ce063db9 100644 --- a/torchquantum/functional/func_mat_exp.py +++ b/torchquantum/functional/func_mat_exp.py @@ -23,13 +23,14 @@ """ import torch -from .functionals import gate_wrapper +from .gate_wrapper import gate_wrapper from typing import Union import numpy as np import torchquantum.functional as tqf __all__ = ["matrix_exp"] + def matrix_exp( qdev, wires, @@ -62,7 +63,7 @@ def matrix_exp( mat = torch.matrix_exp(params) - name = 'qubitunitaryfast' + name = "qubitunitaryfast" tqf.qubitunitaryfast( q_device=qdev, diff --git a/torchquantum/functional/functionals.py b/torchquantum/functional/functionals.py index 6c2dc809..bd4400c7 100644 --- a/torchquantum/functional/functionals.py +++ b/torchquantum/functional/functionals.py @@ -31,4332 +31,3 @@ from ..util.utils import pauli_eigs, diag from torchpack.utils.logging import logger from torchquantum.util import normalize_statevector - -from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm -from .hadamard import hadamard, shadamard, HADAMARD_MATRIX, SHADAMARD_MATRIX - -if TYPE_CHECKING: - from torchquantum.device import QuantumDevice -else: - QuantumDevice = None - -__all__ = [ - "func_name_dict", - "mat_dict", - "apply_unitary_einsum", - "apply_unitary_bmm", - "hadamard", - "shadamard", - "paulix", - "pauliy", - "pauliz", - "i", - "s", - "t", - "sx", - "cnot", - "cz", - "cy", - "swap", - "sswap", - "cswap", - "toffoli", - "multicnot", - "multixcnot", - "rx", - "ry", - "rz", - "rxx", - "ryy", - "rzz", - "rzx", - "phaseshift", - "rot", - "multirz", - "crx", - "cry", - "crz", - "crot", - "u1", - "u2", - "u3", - "cu", - "cu1", - "cu2", - "cu3", - "qubitunitary", - "qubitunitaryfast", - "qubitunitarystrict", - "singleexcitation", - "h", - "sh", - "x", - "y", - "z", - "xx", - "yy", - "zz", - "zx", - "cx", - "ccnot", - "ccx", - "u", - "cu", - "p", - "cp", - "cr", - "cphase", - "reset", - "ecr", - "echoedcrossresonance", - "qft", - "sdg", - "iswap", - "cs", - "csdg", - "csx", - "chadamard", - "ccz", - "dcx", - "xxminyy", - "xxplusyy", - "c3x", - "tdg", - "sxdg", - "ch", - "r", - "c4x", - "rccx", - "rc3x", - "globalphase", - "c3sx", -] - - -def reset(q_device: QuantumDevice, wires, inverse=False): - # reset the target qubits to 0, non-unitary operation - state = q_device.states - - wires = [wires] if isinstance(wires, int) else wires - - for wire in wires: - devices_dim = wire + 1 - permute_to = list(range(state.dim())) - del permute_to[devices_dim] - permute_to += [devices_dim] - permute_back = list(np.argsort(permute_to)) - - # permute the target wire to the last dim - permuted = state.permute(permute_to) - - # reset the state - permuted[..., 1] = 0 - - # permute back - state = state.permute(permute_back) - - # normalize the magnitude of states - q_device.states = normalize_statevector(q_device.states) - - -def rx_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for rx gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - """ - Seems to be a pytorch bug. Have to explicitly cast the theta to a - complex number. If directly theta = params, then get error: - - allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag - RuntimeError: Expected isFloatingType(grad.scalar_type()) || - (input_is_complex == grad_is_complex) to be true, but got false. - (Could this error message be improved? - If so, please report an enhancement request to PyTorch.) - - """ - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(-theta / 2) - - return torch.stack( - [torch.cat([co, jsi], dim=-1), torch.cat([jsi, co], dim=-1)], dim=-2 - ).squeeze(0) - - -def ry_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for ry gate. - - Args: - params: The rotation angle. - - Returns: - The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [torch.cat([co, -si], dim=-1), torch.cat([si, co], dim=-1)], dim=-2 - ).squeeze(0) - - -def rz_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for rz gate. - - Args: - params: The rotation angle. - - Returns: - The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - exp = torch.exp(-0.5j * theta) - - return torch.stack( - [ - torch.cat([exp, torch.zeros(exp.shape, device=params.device)], dim=-1), - torch.cat( - [torch.zeros(exp.shape, device=params.device), torch.conj(exp)], dim=-1 - ), - ], - dim=-2, - ).squeeze(0) - - -def phaseshift_matrix(params): - """Compute unitary matrix for phaseshift gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params.type(C_DTYPE) - exp = torch.exp(1j * phi) - - return torch.stack( - [ - torch.cat( - [ - torch.ones(exp.shape, device=params.device), - torch.zeros(exp.shape, device=params.device), - ], - dim=-1, - ), - torch.cat([torch.zeros(exp.shape, device=params.device), exp], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def rot_matrix(params): - """Compute unitary matrix for rot gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - theta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - omega = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [ - torch.cat( - [ - torch.exp(-0.5j * (phi + omega)) * co, - -torch.exp(0.5j * (phi - omega)) * si, - ], - dim=-1, - ), - torch.cat( - [ - torch.exp(-0.5j * (phi - omega)) * si, - torch.exp(0.5j * (phi + omega)) * co, - ], - dim=-1, - ), - ], - dim=-2, - ).squeeze(0) - - -def xxminyy_matrix(params): - """Compute unitary matrix for XXminusYY gate. - - Args: - params (torch.Tensor): The rotation angle. (Theta,Beta) - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - beta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [ - torch.cat( - [ - co, - torch.tensor([[0]]), - torch.tensor([[0]]), - (-1j * si * torch.exp(-1j * beta)), - ], - dim=-1, - ), - torch.cat( - [ - torch.tensor([[0]]), - torch.tensor([[1]]), - torch.tensor([[0]]), - torch.tensor([[0]]), - ], - dim=-1, - ), - torch.cat( - [ - torch.tensor([[0]]), - torch.tensor([[0]]), - torch.tensor([[1]]), - torch.tensor([[0]]), - ], - dim=-1, - ), - torch.cat( - [ - (-1j * si * torch.exp(1j * beta)), - torch.tensor([[0]]), - torch.tensor([[0]]), - co, - ], - dim=-1, - ), - ], - dim=-2, - ).squeeze(0) - - -def xxplusyy_matrix(params): - """Compute unitary matrix for XXplusYY gate. - - Args: - params (torch.Tensor): The rotation angle. (Theta,Beta) - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - beta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [ - torch.cat( - [ - torch.tensor([[1]]), - torch.tensor([[0]]), - torch.tensor([[0]]), - torch.tensor([[0]]), - ], - dim=-1, - ), - torch.cat( - [ - torch.tensor([[0]]), - co, - (-1j * si * torch.exp(1j * beta)), - torch.tensor([[0]]), - ], - dim=-1, - ), - torch.cat( - [ - torch.tensor([[0]]), - (-1j * si * torch.exp(-1j * beta)), - co, - torch.tensor([[0]]), - ], - dim=-1, - ), - torch.cat( - [ - torch.tensor([[0]]), - torch.tensor([[0]]), - torch.tensor([[0]]), - torch.tensor([[1]]), - ], - dim=-1, - ), - ], - dim=-2, - ).squeeze(0) - - -def multirz_eigvals(params, n_wires): - """Compute eigenvalue for multiqubit RZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed eigenvalues. - - """ - theta = params.type(C_DTYPE) - return torch.exp( - -1j * theta / 2 * torch.tensor(pauli_eigs(n_wires)).to(params.device) - ) - - -def multirz_matrix(params, n_wires): - """Compute unitary matrix for multiqubit RZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - # torch diagonal not available for complex number - eigvals = multirz_eigvals(params, n_wires) - dia = diag(eigvals) - return dia.squeeze(0) - - -def rxx_matrix(params): - """Compute unitary matrix for RXX gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = co[:, 0] - matrix[:, 1, 1] = co[:, 0] - matrix[:, 2, 2] = co[:, 0] - matrix[:, 3, 3] = co[:, 0] - - matrix[:, 0, 3] = -jsi[:, 0] - matrix[:, 1, 2] = -jsi[:, 0] - matrix[:, 2, 1] = -jsi[:, 0] - matrix[:, 3, 0] = -jsi[:, 0] - - return matrix.squeeze(0) - - -def ryy_matrix(params): - """Compute unitary matrix for RYY gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = co[:, 0] - matrix[:, 1, 1] = co[:, 0] - matrix[:, 2, 2] = co[:, 0] - matrix[:, 3, 3] = co[:, 0] - - matrix[:, 0, 3] = jsi[:, 0] - matrix[:, 1, 2] = -jsi[:, 0] - matrix[:, 2, 1] = -jsi[:, 0] - matrix[:, 3, 0] = jsi[:, 0] - - return matrix.squeeze(0) - - -def rzz_matrix(params): - """Compute unitary matrix for RZZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - exp = torch.exp(-0.5j * theta) - conj_exp = torch.conj(exp) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(exp.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = exp[:, 0] - matrix[:, 1, 1] = conj_exp[:, 0] - matrix[:, 2, 2] = conj_exp[:, 0] - matrix[:, 3, 3] = exp[:, 0] - - return matrix.squeeze(0) - - -def rzx_matrix(params): - """Compute unitary matrix for RZX gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = co[:, 0] - matrix[:, 0, 1] = -jsi[:, 0] - - matrix[:, 1, 0] = -jsi[:, 0] - matrix[:, 1, 1] = co[:, 0] - - matrix[:, 2, 2] = co[:, 0] - matrix[:, 2, 3] = jsi[:, 0] - - matrix[:, 3, 2] = jsi[:, 0] - matrix[:, 3, 3] = co[:, 0] - - return matrix.squeeze(0) - - -def crx_matrix(params): - """Compute unitary matrix for CRX gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(-theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - matrix[:, 2, 2] = co[:, 0] - matrix[:, 2, 3] = jsi[:, 0] - matrix[:, 3, 2] = jsi[:, 0] - matrix[:, 3, 3] = co[:, 0] - - return matrix.squeeze(0) - - -def cry_matrix(params): - """Compute unitary matrix for CRY gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - matrix[:, 2, 2] = co[:, 0] - matrix[:, 2, 3] = -si[:, 0] - matrix[:, 3, 2] = si[:, 0] - matrix[:, 3, 3] = co[:, 0] - - return matrix.squeeze(0) - - -def crz_matrix(params): - """Compute unitary matrix for CRZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - exp = torch.exp(-0.5j * theta) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(exp.shape[0], 1, 1) - ) - matrix[:, 2, 2] = exp[:, 0] - matrix[:, 3, 3] = torch.conj(exp[:, 0]) - - return matrix.squeeze(0) - - -def crot_matrix(params): - """Compute unitary matrix for CRot gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params[:, 0].type(C_DTYPE) - theta = params[:, 1].type(C_DTYPE) - omega = params[:, 2].type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 2] = torch.exp(-0.5j * (phi + omega)) * co - matrix[:, 2, 3] = -torch.exp(0.5j * (phi - omega)) * si - matrix[:, 3, 2] = torch.exp(-0.5j * (phi - omega)) * si - matrix[:, 3, 3] = torch.exp(0.5j * (phi + omega)) * co - - return matrix.squeeze(0) - - -def u1_matrix(params): - """Compute unitary matrix for U1 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params.type(C_DTYPE) - exp = torch.exp(1j * phi) - - return torch.stack( - [ - torch.cat( - [ - torch.ones(exp.shape, device=params.device), - torch.zeros(exp.shape, device=params.device), - ], - dim=-1, - ), - torch.cat([torch.zeros(exp.shape, device=params.device), exp], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def cu_matrix(params): - """Compute unitary matrix for CU gate. - Args: - params (torch.Tensor): The rotation angle. - Returns: - torch.Tensor: The computed unitary matrix. - """ - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - gamma = params[:, 3].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 2] = co * torch.exp(1j * gamma) - matrix[:, 2, 3] = -si * torch.exp(1j * (lam + gamma)) - matrix[:, 3, 2] = si * torch.exp(1j * (phi + gamma)) - matrix[:, 3, 3] = co * torch.exp(1j * (phi + lam + gamma)) - - return matrix.squeeze(0) - - -def cu1_matrix(params): - """Compute unitary matrix for CU1 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params.type(C_DTYPE) - exp = torch.exp(1j * phi) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 3, 3] = exp - - return matrix.squeeze(0) - - -def u2_matrix(params): - """Compute unitary matrix for U2 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - - return INV_SQRT2 * torch.stack( - [ - torch.cat( - [torch.ones(phi.shape, device=params.device), -torch.exp(1j * lam)], - dim=-1, - ), - torch.cat([torch.exp(1j * phi), torch.exp(1j * (phi + lam))], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def cu2_matrix(params): - """Compute unitary matrix for CU2 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 3] = -torch.exp(1j * lam) - matrix[:, 3, 2] = torch.exp(1j * phi) - matrix[:, 3, 3] = torch.exp(1j * (phi + lam)) - - return matrix.squeeze(0) - - -def u3_matrix(params): - """Compute unitary matrix for U3 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [ - torch.cat([co, -si * torch.exp(1j * lam)], dim=-1), - torch.cat( - [si * torch.exp(1j * phi), co * torch.exp(1j * (phi + lam))], dim=-1 - ), - ], - dim=-2, - ).squeeze(0) - - -def cu3_matrix(params): - """Compute unitary matrix for CU3 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 2] = co - matrix[:, 2, 3] = -si * torch.exp(1j * lam) - matrix[:, 3, 2] = si * torch.exp(1j * phi) - matrix[:, 3, 3] = co * torch.exp(1j * (phi + lam)) - - return matrix.squeeze(0) - - -def qubitunitary_matrix(params): - """Compute unitary matrix for Qubitunitary gate. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - matrix = params.squeeze(0) - try: - assert matrix.shape[-1] == matrix.shape[-2] - except AssertionError as err: - logger.exception(f"Operator must be a square matrix.") - raise err - - try: - U = matrix.cpu().detach().numpy() - if matrix.dim() > 2: - # batched unitary - bsz = matrix.shape[0] - assert np.allclose( - np.matmul(U, np.transpose(U.conj(), [0, 2, 1])), - np.stack([np.identity(U.shape[-1])] * bsz), - atol=1e-5, - ) - else: - assert np.allclose( - np.matmul(U, np.transpose(U.conj(), [1, 0])), - np.identity(U.shape[0]), - atol=1e-5, - ) - except AssertionError as err: - logger.exception(f"Operator must be unitary.") - raise err - - return matrix - - -def qubitunitaryfast_matrix(params): - """Compute unitary matrix for Qubitunitary fast gate. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - return params.squeeze(0) - - -def qubitunitarystrict_matrix(params): - """Compute unitary matrix for Qubitunitary strict gate. - Strictly be the unitary. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - params.squeeze(0) - mat = params - U, Sigma, V = torch.svd(mat) - return U.matmul(V) - - -def multicnot_matrix(n_wires): - """Compute unitary matrix for Multi qubit CNOT gate. - - Args: - n_wires (int): The number of wires. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - mat = torch.eye(2**n_wires, dtype=C_DTYPE) - mat[-1][-1] = 0 - mat[-2][-2] = 0 - mat[-1][-2] = 1 - mat[-2][-1] = 1 - - return mat - - -def multixcnot_matrix(n_wires): - """Compute unitary matrix for Multi qubit XCNOT gate. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - # when all control qubits are zero, then the target qubit will flip - mat = torch.eye(2**n_wires, dtype=C_DTYPE) - mat[0][0] = 0 - mat[1][1] = 0 - mat[0][1] = 1 - mat[1][0] = 1 - - return mat - - -def singleexcitation_matrix(params): - """Compute unitary matrix for single excitation gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(theta.shape[0], 1, 1) - ) - - matrix[:, 1, 1] = co - matrix[:, 1, 2] = -si - matrix[:, 2, 1] = si - matrix[:, 2, 2] = co - - return matrix.squeeze(0) - - -def qft_matrix(n_wires): - """Compute unitary matrix for QFT. - - Args: - n_wires: the number of qubits - """ - dimension = 2**n_wires - mat = torch.zeros((dimension, dimension), dtype=torch.complex64) - omega = np.exp(2 * np.pi * 1j / dimension) - - for m in range(dimension): - for n in range(dimension): - mat[m, n] = omega ** (m * n) - mat = mat / np.sqrt(dimension) - return mat - - -def r_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for R gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - - """ - - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - exp = torch.exp(-1j * phi) - """ - Seems to be a pytorch bug. Have to explicitly cast the theta to a - complex number. If directly theta = params, then get error: - - allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag - RuntimeError: Expected isFloatingType(grad.scalar_type()) || - (input_is_complex == grad_is_complex) to be true, but got false. - (Could this error message be improved? - If so, please report an enhancement request to PyTorch.) - - """ - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(-theta / 2) - - return torch.stack( - [ - torch.cat([co, exp * jsi], dim=-1), - torch.cat([torch.conj(exp) * jsi, co], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def globalphase_matrix(params): - """Compute unitary matrix for Multi qubit XCNOT gate. - Args: - params (torch.Tensor): The phase. - Returns: - torch.Tensor: The computed unitary matrix. - """ - phase = params.type(C_DTYPE) - exp = torch.exp(1j * phase) - matrix = torch.tensor([[exp]], dtype=C_DTYPE, device=params.device) - - return matrix - - -def c3x_matrix(): - """Compute unitary matrix for C3X. - Args: - None - Returns: - torch.Tensor: The computed unitary matrix. - """ - - mat = torch.eye(16, dtype=C_DTYPE) - mat[15][15] = 0 - mat[14][14] = 0 - mat[15][14] = 1 - mat[14][15] = 1 - - return mat - - -def c4x_matrix(): - """Compute unitary matrix for C4X gate. - Args: - None - Returns: - torch.Tensor: The computed unitary matrix. - """ - mat = torch.eye(32, dtype=C_DTYPE) - mat[30][30] = 0 - mat[30][31] = 1 - mat[31][31] = 0 - mat[31][30] = 1 - - return mat - - -def c3sx_matrix(): - """Compute unitary matrix for c3sx gate. - Args: - None. - Returns: - torch.Tensor: The computed unitary matrix. - """ - mat = torch.eye(16, dtype=C_DTYPE) - mat[14][14] = (1 + 1j) / 2 - mat[14][15] = (1 - 1j) / 2 - mat[15][14] = (1 - 1j) / 2 - mat[15][15] = (1 + 1j) / 2 - - return mat - - -mat_dict = { - "hadamard": HADAMARD_MATRIX, - "shadamard": SHADAMARD_MATRIX, - "paulix": torch.tensor([[0, 1], [1, 0]], dtype=C_DTYPE), - "pauliy": torch.tensor([[0, -1j], [1j, 0]], dtype=C_DTYPE), - "pauliz": torch.tensor([[1, 0], [0, -1]], dtype=C_DTYPE), - "i": torch.tensor([[1, 0], [0, 1]], dtype=C_DTYPE), - "s": torch.tensor([[1, 0], [0, 1j]], dtype=C_DTYPE), - "t": torch.tensor([[1, 0], [0, np.exp(1j * np.pi / 4)]], dtype=C_DTYPE), - "sx": 0.5 * torch.tensor([[1 + 1j, 1 - 1j], [1 - 1j, 1 + 1j]], dtype=C_DTYPE), - "cnot": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]], dtype=C_DTYPE - ), - "cz": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]], dtype=C_DTYPE - ), - "cy": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]], dtype=C_DTYPE - ), - "swap": torch.tensor( - [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=C_DTYPE - ), - "sswap": torch.tensor( - [ - [1, 0, 0, 0], - [0, (1 + 1j) / 2, (1 - 1j) / 2, 0], - [0, (1 - 1j) / 2, (1 + 1j) / 2, 0], - [0, 0, 0, 1], - ], - dtype=C_DTYPE, - ), - "cswap": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 1, 0], - [0, 0, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 1], - ], - dtype=C_DTYPE, - ), - "toffoli": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 1], - [0, 0, 0, 0, 0, 0, 1, 0], - ], - dtype=C_DTYPE, - ), - "ecr": INV_SQRT2 - * torch.tensor( - [[0, 0, 1, 1j], [0, 0, 1j, 1], [1, -1j, 0, 0], [-1j, 1, 0, 0]], dtype=C_DTYPE - ), - "sdg": torch.tensor([[1, 0], [0, -1j]], dtype=C_DTYPE), - "tdg": torch.tensor([[1, 0], [0, np.exp(-1j * np.pi / 4)]], dtype=C_DTYPE), - "sxdg": torch.tensor( - [[0.5 - 0.5j, 0.5 + 0.5j], [0.5 + 0.5j, 0.5 - 0.5j]], dtype=C_DTYPE - ), - "chadamard": torch.tensor( - [ - [1, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, INV_SQRT2, INV_SQRT2], - [0, 0, INV_SQRT2, -INV_SQRT2], - ], - dtype=C_DTYPE, - ), - "iswap": torch.tensor( - [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]], dtype=C_DTYPE - ), - "ccz": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 1, 0], - [0, 0, 0, 0, 0, 0, 0, -1], - ], - dtype=C_DTYPE, - ), - "cs": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1j]], dtype=C_DTYPE - ), - "csdg": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1j]], dtype=C_DTYPE - ), - "csx": torch.tensor( - [ - [1, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, 0.5 + 0.5j, 0.5 - 0.5j], - [0, 0, 0.5 - 0.5j, 0.5 + 0.5j], - ], - dtype=C_DTYPE, - ), - "rx": rx_matrix, - "ry": ry_matrix, - "rz": rz_matrix, - "rxx": rxx_matrix, - "ryy": ryy_matrix, - "rzz": rzz_matrix, - "rzx": rzx_matrix, - "phaseshift": phaseshift_matrix, - "rot": rot_matrix, - "multirz": multirz_matrix, - "crx": crx_matrix, - "cry": cry_matrix, - "crz": crz_matrix, - "crot": crot_matrix, - "u1": u1_matrix, - "u2": u2_matrix, - "u3": u3_matrix, - "cu": cu_matrix, - "cu1": cu1_matrix, - "cu2": cu2_matrix, - "cu3": cu3_matrix, - "qubitunitary": qubitunitary_matrix, - "qubitunitaryfast": qubitunitaryfast_matrix, - "qubitunitarystrict": qubitunitarystrict_matrix, - "multicnot": multicnot_matrix, - "multixcnot": multixcnot_matrix, - "singleexcitation": singleexcitation_matrix, - "qft": qft_matrix, - "dcx": torch.tensor( - [[1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 0, 0]], dtype=C_DTYPE - ), - "xxminyy": xxminyy_matrix, - "xxplusyy": xxplusyy_matrix, - "r": r_matrix, - "globalphase": globalphase_matrix, - "c3x": c3x_matrix(), - "c4x": c4x_matrix(), - "c3sx": c3sx_matrix(), - "rccx": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, -1, 0, 0], - [0, 0, 0, 0, 0, 0, 0, -1j], - [0, 0, 0, 0, 0, 0, 1j, 0], - ], - dtype=C_DTYPE, - ), - "rc3x": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1j, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1j, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0], - ], - dtype=C_DTYPE, - ), -} - - - -def paulix( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the Pauli X gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "paulix" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def pauliy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the Pauli Y gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "pauliy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def pauliz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the Pauli Z gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "pauliz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def i( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the I gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "i" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def s( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the s gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "s" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def t( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the t gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "t" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def sx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the sx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "sx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cnot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cnot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cy gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "rx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def ry( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the ry gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "ry" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "rz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rxx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rxx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "rxx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def ryy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the ryy gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "ryy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rzz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rzz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "rzz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rzx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rzx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "rzx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def swap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the swap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "swap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def sswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the sswap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "sswap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cswap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cswap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def toffoli( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the toffoli gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "toffoli" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def phaseshift( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the phaseshift gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "phaseshift" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "rot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def xxminyy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the XXminusYY gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "xxminyy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def xxplusyy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the XXPlusYY gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "xxplusyy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def multirz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the multi qubit RZ gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "multirz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def crx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the crx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "crx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cry( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cry gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cry" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def crz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the crz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "crz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def crot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the crot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "crot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def u1( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the u1 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "u1" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def u2( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the u2 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "u2" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def u3( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the u3 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "u3" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu gate. - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - Returns: - None. - """ - name = "cu" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu1( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu1 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cu1" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu2( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu2 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cu2" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu3( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu3 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "cu3" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qubitunitary( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the qubitunitary gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "qubitunitary" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qubitunitaryfast( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the qubitunitaryfast gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "qubitunitaryfast" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qubitunitarystrict( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the qubitunitarystrict = gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "qubitunitarystrict" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def c3x( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the c3x gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "c3x" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def multicnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the multi qubit cnot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "multicnot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def multixcnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the multi qubit xcnot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "multixcnot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def singleexcitation( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the single excitation gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "singleexcitation" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def ecr( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the echoed cross-resonance gate. - https://qiskit.org/documentation/stubs/qiskit.circuit.library.ECRGate.html - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "ecr" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qft( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - name = "qft" - if n_wires == None: - wires = [wires] if isinstance(wires, int) else wires - n_wires = len(wires) - - mat = mat_dict[name] - # mat = qft_matrix(n_wires) - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def sdg( - q_device: QuantumDevice, - wires: Union[List[int], int], - params: torch.Tensor = None, - n_wires: int = None, - static: bool = False, - parent_graph=None, - inverse: bool = False, - comp_method: str = "bmm", -): - """Perform the sdg gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "sdg" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def tdg( - q_device: QuantumDevice, - wires: Union[List[int], int], - params: torch.Tensor = None, - n_wires: int = None, - static: bool = False, - parent_graph=None, - inverse: bool = False, - comp_method: str = "bmm", -): - """Perform the tdg gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "tdg" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def sxdg( - q_device: QuantumDevice, - wires: Union[List[int], int], - params: torch.Tensor = None, - n_wires: int = None, - static: bool = False, - parent_graph=None, - inverse: bool = False, - comp_method: str = "bmm", -): - """Perform the sxdg gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "sxdg" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def chadamard( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the chadamard gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - - name = "chadamard" - - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def ccz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the ccz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "ccz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def iswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the iswap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "iswap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cs( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cs gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - - name = "cs" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def csdg( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the csdg gate. - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - - Returns: - None. - - """ - name = "csdg" - - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def csx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the csx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "csx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def dcx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the dcx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "dcx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def r( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the R gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - - """ - name = "r" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def c4x( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the c4x gate. - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - Returns: - None. - """ - name = "c4x" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rc3x( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rc3x (simplified 3-controlled Toffoli) gate. - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - Returns: - None. - """ - name = "rc3x" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rccx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rccx (simplified Toffoli) gate. - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - Returns: - None. - """ - name = "rccx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def globalphase( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the echoed cross-resonance gate. - https://qiskit.org/documentation/stubs/qiskit.circuit.library.ECRGate.html - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - Returns: - None. - """ - name = "globalphase" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def c3sx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the c3sx gate. - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - Returns: - None. - """ - name = "c3sx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -h = hadamard -sh = shadamard -x = paulix -y = pauliy -z = pauliz -xx = rxx -yy = ryy -zz = rzz -zx = rzx -cx = cnot -ccnot = toffoli -ccx = toffoli -u = u3 -p = phaseshift -cp = cu1 -cr = cu1 -cphase = cu1 -echoedcrossresonance = ecr -ch = chadamard - - -func_name_dict = { - "hadamard": hadamard, - "h": h, - "sh": shadamard, - "paulix": paulix, - "pauliy": pauliy, - "pauliz": pauliz, - "i": i, - "s": s, - "t": t, - "sx": sx, - "cnot": cnot, - "cz": cz, - "cy": cy, - "rx": rx, - "ry": ry, - "rz": rz, - "rxx": rxx, - "xx": xx, - "ryy": ryy, - "yy": yy, - "rzz": rzz, - "zz": zz, - "rzx": rzx, - "zx": zx, - "swap": swap, - "sswap": sswap, - "cswap": cswap, - "toffoli": toffoli, - "phaseshift": phaseshift, - "p": p, - "cp": cp, - "rot": rot, - "multirz": multirz, - "crx": crx, - "cry": cry, - "crz": crz, - "crot": crot, - "u1": u1, - "u2": u2, - "u3": u3, - "u": u, - "cu1": cu1, - "cphase": cphase, - "cr": cr, - "cu2": cu2, - "cu3": cu3, - "cu": cu, - "qubitunitary": qubitunitary, - "qubitunitaryfast": qubitunitaryfast, - "qubitunitarystrict": qubitunitarystrict, - "multicnot": multicnot, - "multixcnot": multixcnot, - "x": x, - "y": y, - "z": z, - "cx": cx, - "ccnot": ccnot, - "ccx": ccx, - "reset": reset, - "singleexcitation": singleexcitation, - "ecr": ecr, - "echoedcrossresonance": echoedcrossresonance, - "qft": qft, - "sdg": sdg, - "tdg": tdg, - "sxdg": sxdg, - "ch": ch, - "ccz": ccz, - "iswap": iswap, - "cs": cs, - "csdg": csdg, - "csx": csx, - "chadamard": chadamard, - "ccz": ccz, - "dcx": dcx, - "xxminyy": xxminyy, - "xxplusyy": xxplusyy, - "c3x": c3x, - "r": r, - "globalphase": globalphase, - "c3sx": c3sx, - "rccx": rccx, - "rc3x": rc3x, - "c4x": c4x, -} diff --git a/torchquantum/functional/gate_wrapper.py b/torchquantum/functional/gate_wrapper.py index fa36153a..42889697 100644 --- a/torchquantum/functional/gate_wrapper.py +++ b/torchquantum/functional/gate_wrapper.py @@ -139,7 +139,6 @@ def apply_unitary_bmm(state, mat, wires): return new_state - def gate_wrapper( name, mat, @@ -255,5 +254,3 @@ def gate_wrapper( q_device.states = apply_unitary_einsum(state, matrix, wires) elif method == "bmm": q_device.states = apply_unitary_bmm(state, matrix, wires) - - diff --git a/torchquantum/functional/global_phase.py b/torchquantum/functional/global_phase.py new file mode 100644 index 00000000..9bc4ec54 --- /dev/null +++ b/torchquantum/functional/global_phase.py @@ -0,0 +1,80 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def globalphase_matrix(params): + """Compute unitary matrix for Multi qubit XCNOT gate. + Args: + params (torch.Tensor): The phase. + Returns: + torch.Tensor: The computed unitary matrix. + """ + phase = params.type(C_DTYPE) + exp = torch.exp(1j * phase) + matrix = torch.tensor([[exp]], dtype=C_DTYPE, device=params.device) + + return matrix + + +_globalphase_mat_dict = { + "globalphase": globalphase_matrix, +} + + +def globalphase( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the echoed cross-resonance gate. + https://qiskit.org/documentation/stubs/qiskit.circuit.library.ECRGate.html + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + Returns: + None. + """ + name = "globalphase" + mat = _globalphase_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/hadamard.py b/torchquantum/functional/hadamard.py index 1efdb0ff..a2a45c40 100644 --- a/torchquantum/functional/hadamard.py +++ b/torchquantum/functional/hadamard.py @@ -9,17 +9,28 @@ else: QuantumDevice = None -HADAMARD_MATRIX = torch.tensor( - [[INV_SQRT2, INV_SQRT2], [INV_SQRT2, -INV_SQRT2]], dtype=C_DTYPE -) - -SHADAMARD_MATRIX = torch.tensor( - [ - [np.cos(np.pi / 8), -np.sin(np.pi / 8)], - [np.sin(np.pi / 8), np.cos(np.pi / 8)], - ], - dtype=C_DTYPE, -) +_hadamard_mat_dict = { + "hadamard": torch.tensor( + [[INV_SQRT2, INV_SQRT2], [INV_SQRT2, -INV_SQRT2]], dtype=C_DTYPE + ), + "shadamard": torch.tensor( + [ + [np.cos(np.pi / 8), -np.sin(np.pi / 8)], + [np.sin(np.pi / 8), np.cos(np.pi / 8)], + ], + dtype=C_DTYPE, + ), + "chadamard": torch.tensor( + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, INV_SQRT2, INV_SQRT2], + [0, 0, INV_SQRT2, -INV_SQRT2], + ], + dtype=C_DTYPE, + ), +} + def hadamard( q_device: QuantumDevice, @@ -53,7 +64,7 @@ def hadamard( """ name = "hadamard" - mat = HADAMARD_MATRIX + mat = _hadamard_mat_dict[name] gate_wrapper( name=name, mat=mat, @@ -100,8 +111,56 @@ def shadamard( """ name = "shadamard" + mat = _hadamard_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def chadamard( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the chadamard gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + + name = "chadamard" + mat = mat_dict[name] - mat = SHADAMARD_MATRIX gate_wrapper( name=name, mat=mat, @@ -116,3 +175,6 @@ def shadamard( ) +ch = chadamard +h = hadamard +sh = shadamard diff --git a/torchquantum/functional/i.py b/torchquantum/functional/i.py new file mode 100644 index 00000000..0aca48af --- /dev/null +++ b/torchquantum/functional/i.py @@ -0,0 +1,67 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + +_i_mat_dict = { + "i": torch.tensor([[1, 0], [0, 1]], dtype=C_DTYPE), +} + + +def i( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the I gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "i" + mat = _i_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/paulix.py b/torchquantum/functional/paulix.py new file mode 100644 index 00000000..d07f066f --- /dev/null +++ b/torchquantum/functional/paulix.py @@ -0,0 +1,617 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def multicnot_matrix(n_wires): + """Compute unitary matrix for Multi qubit CNOT gate. + + Args: + n_wires (int): The number of wires. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + mat = torch.eye(2**n_wires, dtype=C_DTYPE) + mat[-1][-1] = 0 + mat[-2][-2] = 0 + mat[-1][-2] = 1 + mat[-2][-1] = 1 + + return mat + + +def multixcnot_matrix(n_wires): + """Compute unitary matrix for Multi qubit XCNOT gate. + + Args: + params (torch.Tensor): The unitary matrix. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + # when all control qubits are zero, then the target qubit will flip + mat = torch.eye(2**n_wires, dtype=C_DTYPE) + mat[0][0] = 0 + mat[1][1] = 0 + mat[0][1] = 1 + mat[1][0] = 1 + + return mat + + +def c3x_matrix(): + """Compute unitary matrix for C3X. + Args: + None + Returns: + torch.Tensor: The computed unitary matrix. + """ + + mat = torch.eye(16, dtype=C_DTYPE) + mat[15][15] = 0 + mat[14][14] = 0 + mat[15][14] = 1 + mat[14][15] = 1 + + return mat + + +def c4x_matrix(): + """Compute unitary matrix for C4X gate. + Args: + None + Returns: + torch.Tensor: The computed unitary matrix. + """ + mat = torch.eye(32, dtype=C_DTYPE) + mat[30][30] = 0 + mat[30][31] = 1 + mat[31][31] = 0 + mat[31][30] = 1 + + return mat + + +_x_mat_dict = { + "paulix": torch.tensor([[0, 1], [1, 0]], dtype=C_DTYPE), + "cnot": torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]], dtype=C_DTYPE + ), + "multicnot": multicnot_matrix, + "multixcnot": multixcnot_matrix, + "c3x": c3x_matrix(), + "c4x": c4x_matrix(), + "dcx": torch.tensor( + [[1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 0, 0]], dtype=C_DTYPE + ), + "toffoli": torch.tensor( + [ + [1, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 1], + [0, 0, 0, 0, 0, 0, 1, 0], + ], + dtype=C_DTYPE, + ), + "rccx": torch.tensor( + [ + [1, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, -1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, -1j], + [0, 0, 0, 0, 0, 0, 1j, 0], + ], + dtype=C_DTYPE, + ), + "rc3x": torch.tensor( + [ + [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1j, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1j, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0], + ], + dtype=C_DTYPE, + ), +} + + +def paulix( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the Pauli X gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "paulix" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cnot( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cnot gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cnot" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def multicnot( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the multi qubit cnot gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "multicnot" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def multixcnot( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the multi qubit xcnot gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "multixcnot" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def c3x( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the c3x gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "c3x" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def c4x( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the c4x gate. + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + Returns: + None. + """ + name = "c4x" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def dcx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the dcx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "dcx" + mat = _x_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def toffoli( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the toffoli gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "toffoli" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def rc3x( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rc3x (simplified 3-controlled Toffoli) gate. + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + Returns: + None. + """ + name = "rc3x" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def rccx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rccx (simplified Toffoli) gate. + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + Returns: + None. + """ + name = "rccx" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +ccnot = toffoli +x = paulix +ccx = toffoli +cx = cnot diff --git a/torchquantum/functional/pauliy.py b/torchquantum/functional/pauliy.py new file mode 100644 index 00000000..08deda64 --- /dev/null +++ b/torchquantum/functional/pauliy.py @@ -0,0 +1,120 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + +_y_mat_dict = { + "pauliy": torch.tensor([[0, -1j], [1j, 0]], dtype=C_DTYPE), + "cy": torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]], dtype=C_DTYPE + ), +} + + +def pauliy( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the Pauli Y gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "pauliy" + mat = _y_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cy( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cy gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cy" + mat = _y_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +y = pauliy diff --git a/torchquantum/functional/pauliz.py b/torchquantum/functional/pauliz.py new file mode 100644 index 00000000..912f2e2e --- /dev/null +++ b/torchquantum/functional/pauliz.py @@ -0,0 +1,180 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + +_z_mat_dict = { + "pauliz": torch.tensor([[1, 0], [0, -1]], dtype=C_DTYPE), + "cz": torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]], dtype=C_DTYPE + ), + "ccz": torch.tensor( + [ + [1, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, -1], + ], + dtype=C_DTYPE, + ), +} + + +def pauliz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the Pauli Z gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "pauliz" + mat = _z_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cz gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cz" + mat = _z_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def ccz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the ccz gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "ccz" + mat = _z_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +z = pauliz diff --git a/torchquantum/functional/phase_shift.py b/torchquantum/functional/phase_shift.py new file mode 100644 index 00000000..e873b834 --- /dev/null +++ b/torchquantum/functional/phase_shift.py @@ -0,0 +1,99 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def phaseshift_matrix(params): + """Compute unitary matrix for phaseshift gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params.type(C_DTYPE) + exp = torch.exp(1j * phi) + + return torch.stack( + [ + torch.cat( + [ + torch.ones(exp.shape, device=params.device), + torch.zeros(exp.shape, device=params.device), + ], + dim=-1, + ), + torch.cat([torch.zeros(exp.shape, device=params.device), exp], dim=-1), + ], + dim=-2, + ).squeeze(0) + + +_phaseshift_mat_dict = { + "phaseshift": phaseshift_matrix, +} + + +def phaseshift( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the phaseshift gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "phaseshift" + mat = _phaseshift_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +p = phaseshift diff --git a/torchquantum/functional/qft.py b/torchquantum/functional/qft.py new file mode 100644 index 00000000..f6281b03 --- /dev/null +++ b/torchquantum/functional/qft.py @@ -0,0 +1,68 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def qft_matrix(n_wires): + """Compute unitary matrix for QFT. + + Args: + n_wires: the number of qubits + """ + dimension = 2**n_wires + mat = torch.zeros((dimension, dimension), dtype=torch.complex64) + omega = np.exp(2 * np.pi * 1j / dimension) + + for m in range(dimension): + for n in range(dimension): + mat[m, n] = omega ** (m * n) + mat = mat / np.sqrt(dimension) + return mat + + +_qft_mat_dict = { + "qft": qft_matrix, +} + + +def qft( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + name = "qft" + if n_wires == None: + wires = [wires] if isinstance(wires, int) else wires + n_wires = len(wires) + + mat = _qft_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/qubit_unitary.py b/torchquantum/functional/qubit_unitary.py new file mode 100644 index 00000000..151680a0 --- /dev/null +++ b/torchquantum/functional/qubit_unitary.py @@ -0,0 +1,234 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def qubitunitary_matrix(params): + """Compute unitary matrix for Qubitunitary gate. + + Args: + params (torch.Tensor): The unitary matrix. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + matrix = params.squeeze(0) + try: + assert matrix.shape[-1] == matrix.shape[-2] + except AssertionError as err: + logger.exception(f"Operator must be a square matrix.") + raise err + + try: + U = matrix.cpu().detach().numpy() + if matrix.dim() > 2: + # batched unitary + bsz = matrix.shape[0] + assert np.allclose( + np.matmul(U, np.transpose(U.conj(), [0, 2, 1])), + np.stack([np.identity(U.shape[-1])] * bsz), + atol=1e-5, + ) + else: + assert np.allclose( + np.matmul(U, np.transpose(U.conj(), [1, 0])), + np.identity(U.shape[0]), + atol=1e-5, + ) + except AssertionError as err: + logger.exception(f"Operator must be unitary.") + raise err + + return matrix + + +def qubitunitaryfast_matrix(params): + """Compute unitary matrix for Qubitunitary fast gate. + + Args: + params (torch.Tensor): The unitary matrix. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + return params.squeeze(0) + + +def qubitunitarystrict_matrix(params): + """Compute unitary matrix for Qubitunitary strict gate. + Strictly be the unitary. + + Args: + params (torch.Tensor): The unitary matrix. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + params.squeeze(0) + mat = params + U, Sigma, V = torch.svd(mat) + return U.matmul(V) + + +_qubitunitary_mat_dict = { + "qubitunitary": qubitunitary_matrix, + "qubitunitaryfast": qubitunitaryfast_matrix, + "qubitunitarystrict": qubitunitarystrict_matrix, +} + + +def qubitunitary( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the qubitunitary gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "qubitunitary" + mat = _qubitunitary_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def qubitunitaryfast( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the qubitunitaryfast gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "qubitunitaryfast" + mat = _qubitunitary_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def qubitunitarystrict( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the qubitunitarystrict = gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "qubitunitarystrict" + mat = _qubitunitary_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/r.py b/torchquantum/functional/r.py new file mode 100644 index 00000000..d788e418 --- /dev/null +++ b/torchquantum/functional/r.py @@ -0,0 +1,105 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def r_matrix(params: torch.Tensor) -> torch.Tensor: + """Compute unitary matrix for R gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + exp = torch.exp(-1j * phi) + """ + Seems to be a pytorch bug. Have to explicitly cast the theta to a + complex number. If directly theta = params, then get error: + + allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag + RuntimeError: Expected isFloatingType(grad.scalar_type()) || + (input_is_complex == grad_is_complex) to be true, but got false. + (Could this error message be improved? + If so, please report an enhancement request to PyTorch.) + + """ + co = torch.cos(theta / 2) + jsi = 1j * torch.sin(-theta / 2) + + return torch.stack( + [ + torch.cat([co, exp * jsi], dim=-1), + torch.cat([torch.conj(exp) * jsi, co], dim=-1), + ], + dim=-2, + ).squeeze(0) + + +_r_mat_dict = { + "r": r_matrix, +} + + +def r( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the R gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "r" + mat = _r_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/reset.py b/torchquantum/functional/reset.py new file mode 100644 index 00000000..0053ea3d --- /dev/null +++ b/torchquantum/functional/reset.py @@ -0,0 +1,42 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def reset(q_device: QuantumDevice, wires, inverse=False): + # reset the target qubits to 0, non-unitary operation + state = q_device.states + + wires = [wires] if isinstance(wires, int) else wires + + for wire in wires: + devices_dim = wire + 1 + permute_to = list(range(state.dim())) + del permute_to[devices_dim] + permute_to += [devices_dim] + permute_back = list(np.argsort(permute_to)) + + # permute the target wire to the last dim + permuted = state.permute(permute_to) + + # reset the state + permuted[..., 1] = 0 + + # permute back + state = state.permute(permute_back) + + # normalize the magnitude of states + q_device.states = normalize_statevector(q_device.states) diff --git a/torchquantum/functional/rot.py b/torchquantum/functional/rot.py new file mode 100644 index 00000000..1de26ef3 --- /dev/null +++ b/torchquantum/functional/rot.py @@ -0,0 +1,189 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def rot_matrix(params): + """Compute unitary matrix for rot gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + theta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + omega = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + return torch.stack( + [ + torch.cat( + [ + torch.exp(-0.5j * (phi + omega)) * co, + -torch.exp(0.5j * (phi - omega)) * si, + ], + dim=-1, + ), + torch.cat( + [ + torch.exp(-0.5j * (phi - omega)) * si, + torch.exp(0.5j * (phi + omega)) * co, + ], + dim=-1, + ), + ], + dim=-2, + ).squeeze(0) + + +def crot_matrix(params): + """Compute unitary matrix for CRot gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params[:, 0].type(C_DTYPE) + theta = params[:, 1].type(C_DTYPE) + omega = params[:, 2].type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(phi.shape[0], 1, 1) + ) + + matrix[:, 2, 2] = torch.exp(-0.5j * (phi + omega)) * co + matrix[:, 2, 3] = -torch.exp(0.5j * (phi - omega)) * si + matrix[:, 3, 2] = torch.exp(-0.5j * (phi - omega)) * si + matrix[:, 3, 3] = torch.exp(0.5j * (phi + omega)) * co + + return matrix.squeeze(0) + + +_rot_mat_dict = { + "rot": rot_matrix, + "crot": crot_matrix, +} + + +def rot( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rot gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "rot" + mat = _rot_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def crot( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the crot gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "crot" + mat = _rot_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/rx.py b/torchquantum/functional/rx.py new file mode 100644 index 00000000..a1c5d732 --- /dev/null +++ b/torchquantum/functional/rx.py @@ -0,0 +1,266 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def rx_matrix(params: torch.Tensor) -> torch.Tensor: + """Compute unitary matrix for rx gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + """ + Seems to be a pytorch bug. Have to explicitly cast the theta to a + complex number. If directly theta = params, then get error: + + allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag + RuntimeError: Expected isFloatingType(grad.scalar_type()) || + (input_is_complex == grad_is_complex) to be true, but got false. + (Could this error message be improved? + If so, please report an enhancement request to PyTorch.) + + """ + co = torch.cos(theta / 2) + jsi = 1j * torch.sin(-theta / 2) + + return torch.stack( + [torch.cat([co, jsi], dim=-1), torch.cat([jsi, co], dim=-1)], dim=-2 + ).squeeze(0) + + +def rxx_matrix(params): + """Compute unitary matrix for RXX gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + + theta = params.type(C_DTYPE) + co = torch.cos(theta / 2) + jsi = 1j * torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(co.shape[0], 1, 1) + ) + + matrix[:, 0, 0] = co[:, 0] + matrix[:, 1, 1] = co[:, 0] + matrix[:, 2, 2] = co[:, 0] + matrix[:, 3, 3] = co[:, 0] + + matrix[:, 0, 3] = -jsi[:, 0] + matrix[:, 1, 2] = -jsi[:, 0] + matrix[:, 2, 1] = -jsi[:, 0] + matrix[:, 3, 0] = -jsi[:, 0] + + return matrix.squeeze(0) + + +def crx_matrix(params): + """Compute unitary matrix for CRX gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + co = torch.cos(theta / 2) + jsi = 1j * torch.sin(-theta / 2) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(co.shape[0], 1, 1) + ) + matrix[:, 2, 2] = co[:, 0] + matrix[:, 2, 3] = jsi[:, 0] + matrix[:, 3, 2] = jsi[:, 0] + matrix[:, 3, 3] = co[:, 0] + + return matrix.squeeze(0) + + +_rx_mat_dict = { + "rx": rx_matrix, + "rxx": rxx_matrix, + "crx": crx_matrix, +} + + +def rx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "rx" + mat = _rx_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def rxx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rxx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "rxx" + mat = _rx_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def crx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the crx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "crx" + mat = _rx_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +xx = rxx diff --git a/torchquantum/functional/ry.py b/torchquantum/functional/ry.py new file mode 100644 index 00000000..d098c7df --- /dev/null +++ b/torchquantum/functional/ry.py @@ -0,0 +1,255 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def cry_matrix(params): + """Compute unitary matrix for CRY gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(co.shape[0], 1, 1) + ) + matrix[:, 2, 2] = co[:, 0] + matrix[:, 2, 3] = -si[:, 0] + matrix[:, 3, 2] = si[:, 0] + matrix[:, 3, 3] = co[:, 0] + + return matrix.squeeze(0) + + +def ry_matrix(params: torch.Tensor) -> torch.Tensor: + """Compute unitary matrix for ry gate. + + Args: + params: The rotation angle. + + Returns: + The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + return torch.stack( + [torch.cat([co, -si], dim=-1), torch.cat([si, co], dim=-1)], dim=-2 + ).squeeze(0) + + +def ryy_matrix(params): + """Compute unitary matrix for RYY gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + co = torch.cos(theta / 2) + jsi = 1j * torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(co.shape[0], 1, 1) + ) + + matrix[:, 0, 0] = co[:, 0] + matrix[:, 1, 1] = co[:, 0] + matrix[:, 2, 2] = co[:, 0] + matrix[:, 3, 3] = co[:, 0] + + matrix[:, 0, 3] = jsi[:, 0] + matrix[:, 1, 2] = -jsi[:, 0] + matrix[:, 2, 1] = -jsi[:, 0] + matrix[:, 3, 0] = jsi[:, 0] + + return matrix.squeeze(0) + + +def ryy( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the ryy gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "ryy" + mat = _ry_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +_ry_mat_dict = { + "ry": ry_matrix, + "ryy": ryy_matrix, + "cry": cry_matrix, +} + + +def cry( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cry gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cry" + mat = _ry_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def ry( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the ry gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "ry" + mat = _ry_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +yy = ryy diff --git a/torchquantum/functional/rz.py b/torchquantum/functional/rz.py new file mode 100644 index 00000000..0cc0c651 --- /dev/null +++ b/torchquantum/functional/rz.py @@ -0,0 +1,419 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def multirz_eigvals(params, n_wires): + """Compute eigenvalue for multiqubit RZ gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed eigenvalues. + + """ + theta = params.type(C_DTYPE) + return torch.exp( + -1j * theta / 2 * torch.tensor(pauli_eigs(n_wires)).to(params.device) + ) + + +def multirz_matrix(params, n_wires): + """Compute unitary matrix for multiqubit RZ gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + # torch diagonal not available for complex number + eigvals = multirz_eigvals(params, n_wires) + dia = diag(eigvals) + return dia.squeeze(0) + + +def rzz_matrix(params): + """Compute unitary matrix for RZZ gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + exp = torch.exp(-0.5j * theta) + conj_exp = torch.conj(exp) + + matrix = ( + torch.tensor( + [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(exp.shape[0], 1, 1) + ) + + matrix[:, 0, 0] = exp[:, 0] + matrix[:, 1, 1] = conj_exp[:, 0] + matrix[:, 2, 2] = conj_exp[:, 0] + matrix[:, 3, 3] = exp[:, 0] + + return matrix.squeeze(0) + + +def rzx_matrix(params): + """Compute unitary matrix for RZX gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + co = torch.cos(theta / 2) + jsi = 1j * torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(co.shape[0], 1, 1) + ) + + matrix[:, 0, 0] = co[:, 0] + matrix[:, 0, 1] = -jsi[:, 0] + + matrix[:, 1, 0] = -jsi[:, 0] + matrix[:, 1, 1] = co[:, 0] + + matrix[:, 2, 2] = co[:, 0] + matrix[:, 2, 3] = jsi[:, 0] + + matrix[:, 3, 2] = jsi[:, 0] + matrix[:, 3, 3] = co[:, 0] + + return matrix.squeeze(0) + + +def crz_matrix(params): + """Compute unitary matrix for CRZ gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + exp = torch.exp(-0.5j * theta) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(exp.shape[0], 1, 1) + ) + matrix[:, 2, 2] = exp[:, 0] + matrix[:, 3, 3] = torch.conj(exp[:, 0]) + + return matrix.squeeze(0) + + +def rz_matrix(params: torch.Tensor) -> torch.Tensor: + """Compute unitary matrix for rz gate. + + Args: + params: The rotation angle. + + Returns: + The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + exp = torch.exp(-0.5j * theta) + + return torch.stack( + [ + torch.cat([exp, torch.zeros(exp.shape, device=params.device)], dim=-1), + torch.cat( + [torch.zeros(exp.shape, device=params.device), torch.conj(exp)], dim=-1 + ), + ], + dim=-2, + ).squeeze(0) + + +_rz_mat_dict = { + "multirz": multirz_matrix, + "rz": rz_matrix, + "rzz": rzz_matrix, + "crz": crz_matrix, + "rzx": rzx_matrix, +} + + +def multirz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the multi qubit RZ gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "multirz" + mat = _rz_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def crz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the crz gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "crz" + mat = _rz_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def rz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rz gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "rz" + mat = _rz_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def rzz( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rzz gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "rzz" + mat = _rz_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def rzx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the rzx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "rzx" + mat = _rz_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +zz = rzz +zx = rzx diff --git a/torchquantum/functional/s.py b/torchquantum/functional/s.py new file mode 100644 index 00000000..35e5aeaf --- /dev/null +++ b/torchquantum/functional/s.py @@ -0,0 +1,218 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +_s_mat_dict = { + "s": torch.tensor([[1, 0], [0, 1j]], dtype=C_DTYPE), + "sdg": torch.tensor([[1, 0], [0, -1j]], dtype=C_DTYPE), + "cs": torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1j]], dtype=C_DTYPE + ), + "csdg": torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1j]], dtype=C_DTYPE + ), +} + + +def s( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the s gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "s" + mat = _s_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def sdg( + q_device: QuantumDevice, + wires: Union[List[int], int], + params: torch.Tensor = None, + n_wires: int = None, + static: bool = False, + parent_graph=None, + inverse: bool = False, + comp_method: str = "bmm", +): + """Perform the sdg gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "sdg" + mat = _s_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cs( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cs gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevicehadamard__s_mat_dict. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + + name = "cs" + mat = _s_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def csdg( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the csdg gate. + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + + Returns: + None. + + """ + name = "csdg" + + mat = _s_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/single_excitation.py b/torchquantum/functional/single_excitation.py new file mode 100644 index 00000000..f73dd6b9 --- /dev/null +++ b/torchquantum/functional/single_excitation.py @@ -0,0 +1,100 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def singleexcitation_matrix(params): + """Compute unitary matrix for single excitation gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params.type(C_DTYPE) + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(theta.shape[0], 1, 1) + ) + + matrix[:, 1, 1] = co + matrix[:, 1, 2] = -si + matrix[:, 2, 1] = si + matrix[:, 2, 2] = co + + return matrix.squeeze(0) + + +_singleexcitation_mat_dict = { + "singleexcitation": singleexcitation_matrix, +} + + +def singleexcitation( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the single excitation gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "singleexcitation" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/swap.py b/torchquantum/functional/swap.py new file mode 100644 index 00000000..9c1ddb16 --- /dev/null +++ b/torchquantum/functional/swap.py @@ -0,0 +1,236 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +_swap_mat_dict = { + "swap": torch.tensor( + [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=C_DTYPE + ), + "sswap": torch.tensor( + [ + [1, 0, 0, 0], + [0, (1 + 1j) / 2, (1 - 1j) / 2, 0], + [0, (1 - 1j) / 2, (1 + 1j) / 2, 0], + [0, 0, 0, 1], + ], + dtype=C_DTYPE, + ), + "cswap": torch.tensor( + [ + [1, 0, 0, 0, 0, 0, 0, 0], + [0, 1, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 1], + ], + dtype=C_DTYPE, + ), + "iswap": torch.tensor( + [[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]], dtype=C_DTYPE + ), +} + + +def swap( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the swap gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "swap" + mat = _swap_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def sswap( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the sswap gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "sswap" + mat = _swap_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cswap( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cswap gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cswap" + mat = _swap_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def iswap( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the iswap gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "iswap" + mat = _swap_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/sx.py b/torchquantum/functional/sx.py new file mode 100644 index 00000000..7f991b4a --- /dev/null +++ b/torchquantum/functional/sx.py @@ -0,0 +1,235 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def c3sx_matrix(): + """Compute unitary matrix for c3sx gate. + Args: + None. + Returns: + torch.Tensor: The computed unitary matrix. + """ + mat = torch.eye(16, dtype=C_DTYPE) + mat[14][14] = (1 + 1j) / 2 + mat[14][15] = (1 - 1j) / 2 + mat[15][14] = (1 - 1j) / 2 + mat[15][15] = (1 + 1j) / 2 + + return mat + + +_sx_mat_dict = { + "sx": 0.5 * torch.tensor([[1 + 1j, 1 - 1j], [1 - 1j, 1 + 1j]], dtype=C_DTYPE), + "sxdg": torch.tensor( + [[0.5 - 0.5j, 0.5 + 0.5j], [0.5 + 0.5j, 0.5 - 0.5j]], dtype=C_DTYPE + ), + "c3sx": c3sx_matrix(), + "csx": torch.tensor( + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 0.5 + 0.5j, 0.5 - 0.5j], + [0, 0, 0.5 - 0.5j, 0.5 + 0.5j], + ], + dtype=C_DTYPE, + ), +} + + +def sx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the sx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "sx" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def sxdg( + q_device: QuantumDevice, + wires: Union[List[int], int], + params: torch.Tensor = None, + n_wires: int = None, + static: bool = False, + parent_graph=None, + inverse: bool = False, + comp_method: str = "bmm", +): + """Perform the sxdg gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "sxdg" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def csx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the csx gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "csx" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def c3sx( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the c3sx gate. + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + Returns: + None. + """ + name = "c3sx" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/t.py b/torchquantum/functional/t.py new file mode 100644 index 00000000..7ef04e1d --- /dev/null +++ b/torchquantum/functional/t.py @@ -0,0 +1,116 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +_t_mat_dict = { + "t": torch.tensor([[1, 0], [0, np.exp(1j * np.pi / 4)]], dtype=C_DTYPE), + "tdg": torch.tensor([[1, 0], [0, np.exp(-1j * np.pi / 4)]], dtype=C_DTYPE), +} + + +def t( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the t gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "t" + mat = _t_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def tdg( + q_device: QuantumDevice, + wires: Union[List[int], int], + params: torch.Tensor = None, + n_wires: int = None, + static: bool = False, + parent_graph=None, + inverse: bool = False, + comp_method: str = "bmm", +): + """Perform the tdg gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "tdg" + mat = _t_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/u1.py b/torchquantum/functional/u1.py new file mode 100644 index 00000000..05a94910 --- /dev/null +++ b/torchquantum/functional/u1.py @@ -0,0 +1,177 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def u1_matrix(params): + """Compute unitary matrix for U1 gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params.type(C_DTYPE) + exp = torch.exp(1j * phi) + + return torch.stack( + [ + torch.cat( + [ + torch.ones(exp.shape, device=params.device), + torch.zeros(exp.shape, device=params.device), + ], + dim=-1, + ), + torch.cat([torch.zeros(exp.shape, device=params.device), exp], dim=-1), + ], + dim=-2, + ).squeeze(0) + + +def cu1_matrix(params): + """Compute unitary matrix for CU1 gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params.type(C_DTYPE) + exp = torch.exp(1j * phi) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(phi.shape[0], 1, 1) + ) + + matrix[:, 3, 3] = exp + + return matrix.squeeze(0) + + +_u1_mat_dict = { + "u1": u1_matrix, + "cu1": cu1_matrix, +} + + +def u1( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the u1 gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "u1" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cu1( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cu1 gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cu1" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +cp = cu1 +cr = cu1 +cphase = cu1 diff --git a/torchquantum/functional/u2.py b/torchquantum/functional/u2.py new file mode 100644 index 00000000..5a1d9b21 --- /dev/null +++ b/torchquantum/functional/u2.py @@ -0,0 +1,171 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def u2_matrix(params): + """Compute unitary matrix for U2 gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + + return INV_SQRT2 * torch.stack( + [ + torch.cat( + [torch.ones(phi.shape, device=params.device), -torch.exp(1j * lam)], + dim=-1, + ), + torch.cat([torch.exp(1j * phi), torch.exp(1j * (phi + lam))], dim=-1), + ], + dim=-2, + ).squeeze(0) + + +def cu2_matrix(params): + """Compute unitary matrix for CU2 gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(phi.shape[0], 1, 1) + ) + + matrix[:, 2, 3] = -torch.exp(1j * lam) + matrix[:, 3, 2] = torch.exp(1j * phi) + matrix[:, 3, 3] = torch.exp(1j * (phi + lam)) + + return matrix.squeeze(0) + + +_u2_mat_dict = { + "u2": u2_matrix, + "cu2": cu2_matrix, +} + + +def u2( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the u2 gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "u2" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cu2( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cu2 gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cu2" + mat = mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/u3.py b/torchquantum/functional/u3.py new file mode 100644 index 00000000..9dd0927f --- /dev/null +++ b/torchquantum/functional/u3.py @@ -0,0 +1,260 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def cu_matrix(params): + """Compute unitary matrix for CU gate. + Args: + params (torch.Tensor): The rotation angle. + Returns: + torch.Tensor: The computed unitary matrix. + """ + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) + gamma = params[:, 3].unsqueeze(dim=-1).type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(phi.shape[0], 1, 1) + ) + + matrix[:, 2, 2] = co * torch.exp(1j * gamma) + matrix[:, 2, 3] = -si * torch.exp(1j * (lam + gamma)) + matrix[:, 3, 2] = si * torch.exp(1j * (phi + gamma)) + matrix[:, 3, 3] = co * torch.exp(1j * (phi + lam + gamma)) + + return matrix.squeeze(0) + + +def u3_matrix(params): + """Compute unitary matrix for U3 gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + return torch.stack( + [ + torch.cat([co, -si * torch.exp(1j * lam)], dim=-1), + torch.cat( + [si * torch.exp(1j * phi), co * torch.exp(1j * (phi + lam))], dim=-1 + ), + ], + dim=-2, + ).squeeze(0) + + +def cu3_matrix(params): + """Compute unitary matrix for CU3 gate. + + Args: + params (torch.Tensor): The rotation angle. + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + matrix = ( + torch.tensor( + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], + dtype=C_DTYPE, + device=params.device, + ) + .unsqueeze(0) + .repeat(phi.shape[0], 1, 1) + ) + + matrix[:, 2, 2] = co + matrix[:, 2, 3] = -si * torch.exp(1j * lam) + matrix[:, 3, 2] = si * torch.exp(1j * phi) + matrix[:, 3, 3] = co * torch.exp(1j * (phi + lam)) + + return matrix.squeeze(0) + + +_u3_mat_dict = { + "u3": u3_matrix, + "cu3": cu3_matrix, + "cu": cu_matrix, +} + + +def u3( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the u3 gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "u3" + mat = _u3_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cu( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cu gate. + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + Returns: + None. + """ + name = "cu" + mat = _u3_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +def cu3( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the cu3 gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "cu3" + mat = _u3_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) + + +u = u3 diff --git a/torchquantum/functional/xx_min_yy.py b/torchquantum/functional/xx_min_yy.py new file mode 100644 index 00000000..61441857 --- /dev/null +++ b/torchquantum/functional/xx_min_yy.py @@ -0,0 +1,127 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def xxminyy_matrix(params): + """Compute unitary matrix for XXminusYY gate. + + Args: + params (torch.Tensor): The rotation angle. (Theta,Beta) + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + beta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + return torch.stack( + [ + torch.cat( + [ + co, + torch.tensor([[0]]), + torch.tensor([[0]]), + (-1j * si * torch.exp(-1j * beta)), + ], + dim=-1, + ), + torch.cat( + [ + torch.tensor([[0]]), + torch.tensor([[1]]), + torch.tensor([[0]]), + torch.tensor([[0]]), + ], + dim=-1, + ), + torch.cat( + [ + torch.tensor([[0]]), + torch.tensor([[0]]), + torch.tensor([[1]]), + torch.tensor([[0]]), + ], + dim=-1, + ), + torch.cat( + [ + (-1j * si * torch.exp(1j * beta)), + torch.tensor([[0]]), + torch.tensor([[0]]), + co, + ], + dim=-1, + ), + ], + dim=-2, + ).squeeze(0) + + +_xxminyy_mat_dict = { + "xxminyy": xxminyy_matrix, +} + + +def xxminyy( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the XXminusYY gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "xxminyy" + mat = _xxminyy_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/functional/xx_plus_yy.py b/torchquantum/functional/xx_plus_yy.py new file mode 100644 index 00000000..24e0e8aa --- /dev/null +++ b/torchquantum/functional/xx_plus_yy.py @@ -0,0 +1,127 @@ +import functools +import torch +import numpy as np + +from typing import Callable, Union, Optional, List, Dict, TYPE_CHECKING +from ..macro import C_DTYPE, F_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag +from torchpack.utils.logging import logger +from torchquantum.util import normalize_statevector + +from .gate_wrapper import gate_wrapper, apply_unitary_einsum, apply_unitary_bmm + +if TYPE_CHECKING: + from torchquantum.device import QuantumDevice +else: + QuantumDevice = None + + +def xxplusyy_matrix(params): + """Compute unitary matrix for XXplusYY gate. + + Args: + params (torch.Tensor): The rotation angle. (Theta,Beta) + + Returns: + torch.Tensor: The computed unitary matrix. + + """ + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) + beta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) + + co = torch.cos(theta / 2) + si = torch.sin(theta / 2) + + return torch.stack( + [ + torch.cat( + [ + torch.tensor([[1]]), + torch.tensor([[0]]), + torch.tensor([[0]]), + torch.tensor([[0]]), + ], + dim=-1, + ), + torch.cat( + [ + torch.tensor([[0]]), + co, + (-1j * si * torch.exp(1j * beta)), + torch.tensor([[0]]), + ], + dim=-1, + ), + torch.cat( + [ + torch.tensor([[0]]), + (-1j * si * torch.exp(-1j * beta)), + co, + torch.tensor([[0]]), + ], + dim=-1, + ), + torch.cat( + [ + torch.tensor([[0]]), + torch.tensor([[0]]), + torch.tensor([[0]]), + torch.tensor([[1]]), + ], + dim=-1, + ), + ], + dim=-2, + ).squeeze(0) + + +_xxplusyy_mat_dict = { + "xxplusyy": xxplusyy_matrix, +} + + +def xxplusyy( + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", +): + """Perform the XXPlusYY gate. + + Args: + q_device (tq.QuantumDevice): The QuantumDevice. + wires (Union[List[int], int]): Which qubit(s) to apply the gate. + params (torch.Tensor, optional): Parameters (if any) of the gate. + Default to None. + n_wires (int, optional): Number of qubits the gate is applied to. + Default to None. + static (bool, optional): Whether use static mode computation. + Default to False. + parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of + current operation. Default to None. + inverse (bool, optional): Whether inverse the gate. Default to False. + comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform + matrix vector multiplication. Default to 'bmm'. + + Returns: + None. + + """ + name = "xxplusyy" + mat = _xxplusyy_mat_dict[name] + gate_wrapper( + name=name, + mat=mat, + method=comp_method, + q_device=q_device, + wires=wires, + params=params, + n_wires=n_wires, + static=static, + parent_graph=parent_graph, + inverse=inverse, + ) diff --git a/torchquantum/operator/standard_gates/ecr.py b/torchquantum/operator/standard_gates/ecr.py index 32202a34..b709b195 100644 --- a/torchquantum/operator/standard_gates/ecr.py +++ b/torchquantum/operator/standard_gates/ecr.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class ECR(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/global_phase.py b/torchquantum/operator/standard_gates/global_phase.py index 6dad8825..b21454ce 100644 --- a/torchquantum/operator/standard_gates/global_phase.py +++ b/torchquantum/operator/standard_gates/global_phase.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class GlobalPhase(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/hadamard.py b/torchquantum/operator/standard_gates/hadamard.py index d2a62657..1e4f6b13 100644 --- a/torchquantum/operator/standard_gates/hadamard.py +++ b/torchquantum/operator/standard_gates/hadamard.py @@ -2,7 +2,7 @@ import torch import torch.nn as nn import torchquantum as tq -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf import numpy as np from abc import ABCMeta from torchquantum.macro import C_DTYPE, F_DTYPE diff --git a/torchquantum/operator/standard_gates/i.py b/torchquantum/operator/standard_gates/i.py index 36a18c15..fba4ec3f 100644 --- a/torchquantum/operator/standard_gates/i.py +++ b/torchquantum/operator/standard_gates/i.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class I(Observable, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/iswap.py b/torchquantum/operator/standard_gates/iswap.py index 51bbc04c..97f30c56 100644 --- a/torchquantum/operator/standard_gates/iswap.py +++ b/torchquantum/operator/standard_gates/iswap.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class ISWAP(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/paulix.py b/torchquantum/operator/standard_gates/paulix.py index ced51e33..f42bd81d 100644 --- a/torchquantum/operator/standard_gates/paulix.py +++ b/torchquantum/operator/standard_gates/paulix.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class PauliX(Observable, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/pauliy.py b/torchquantum/operator/standard_gates/pauliy.py index ed3f0556..8d65d25a 100644 --- a/torchquantum/operator/standard_gates/pauliy.py +++ b/torchquantum/operator/standard_gates/pauliy.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class PauliY(Observable, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/pauliz.py b/torchquantum/operator/standard_gates/pauliz.py index a4903147..62f7af69 100644 --- a/torchquantum/operator/standard_gates/pauliz.py +++ b/torchquantum/operator/standard_gates/pauliz.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class PauliZ(Observable, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/phase_shift.py b/torchquantum/operator/standard_gates/phase_shift.py index d60efd5f..0e720fb4 100644 --- a/torchquantum/operator/standard_gates/phase_shift.py +++ b/torchquantum/operator/standard_gates/phase_shift.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class PhaseShift(DiagonalOperation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/qft.py b/torchquantum/operator/standard_gates/qft.py index 66ac6022..2bef173c 100644 --- a/torchquantum/operator/standard_gates/qft.py +++ b/torchquantum/operator/standard_gates/qft.py @@ -4,8 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf - +import torchquantum.functional as tqf class QFT(Observable, metaclass=ABCMeta): """Class for Quantum Fourier Transform.""" diff --git a/torchquantum/operator/standard_gates/qubit_unitary.py b/torchquantum/operator/standard_gates/qubit_unitary.py index f6413ed5..5f7fd9b1 100644 --- a/torchquantum/operator/standard_gates/qubit_unitary.py +++ b/torchquantum/operator/standard_gates/qubit_unitary.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf import numpy as np diff --git a/torchquantum/operator/standard_gates/r.py b/torchquantum/operator/standard_gates/r.py index 34cf50e4..b6f5e097 100644 --- a/torchquantum/operator/standard_gates/r.py +++ b/torchquantum/operator/standard_gates/r.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class R(DiagonalOperation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/reset.py b/torchquantum/operator/standard_gates/reset.py index d97c4de7..20a35e28 100644 --- a/torchquantum/operator/standard_gates/reset.py +++ b/torchquantum/operator/standard_gates/reset.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class Reset(Operator, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/rot.py b/torchquantum/operator/standard_gates/rot.py index ba9fd8bb..af0f1334 100644 --- a/torchquantum/operator/standard_gates/rot.py +++ b/torchquantum/operator/standard_gates/rot.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class Rot(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/rx.py b/torchquantum/operator/standard_gates/rx.py index fa805e26..56b81ad9 100644 --- a/torchquantum/operator/standard_gates/rx.py +++ b/torchquantum/operator/standard_gates/rx.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class RX(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/ry.py b/torchquantum/operator/standard_gates/ry.py index f4c7a7a5..277443b9 100644 --- a/torchquantum/operator/standard_gates/ry.py +++ b/torchquantum/operator/standard_gates/ry.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class RY(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/rz.py b/torchquantum/operator/standard_gates/rz.py index 91dee8db..7967c2e9 100644 --- a/torchquantum/operator/standard_gates/rz.py +++ b/torchquantum/operator/standard_gates/rz.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class RZ(DiagonalOperation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/s.py b/torchquantum/operator/standard_gates/s.py index b91aa0c3..8ae83041 100644 --- a/torchquantum/operator/standard_gates/s.py +++ b/torchquantum/operator/standard_gates/s.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class S(DiagonalOperation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/single_excitation.py b/torchquantum/operator/standard_gates/single_excitation.py index 2011aca1..3a452002 100644 --- a/torchquantum/operator/standard_gates/single_excitation.py +++ b/torchquantum/operator/standard_gates/single_excitation.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class SingleExcitation(Operator, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/swap.py b/torchquantum/operator/standard_gates/swap.py index 1214a4c5..a676791e 100644 --- a/torchquantum/operator/standard_gates/swap.py +++ b/torchquantum/operator/standard_gates/swap.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class SWAP(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/sx.py b/torchquantum/operator/standard_gates/sx.py index 5728839a..5fb12942 100644 --- a/torchquantum/operator/standard_gates/sx.py +++ b/torchquantum/operator/standard_gates/sx.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class SX(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/t.py b/torchquantum/operator/standard_gates/t.py index 282fc68b..34bdeca4 100644 --- a/torchquantum/operator/standard_gates/t.py +++ b/torchquantum/operator/standard_gates/t.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class T(DiagonalOperation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/toffoli.py b/torchquantum/operator/standard_gates/toffoli.py index d70178b0..cf593109 100644 --- a/torchquantum/operator/standard_gates/toffoli.py +++ b/torchquantum/operator/standard_gates/toffoli.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class Toffoli(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/trainable_unitary.py b/torchquantum/operator/standard_gates/trainable_unitary.py index c6ea0451..8212700f 100644 --- a/torchquantum/operator/standard_gates/trainable_unitary.py +++ b/torchquantum/operator/standard_gates/trainable_unitary.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class TrainableUnitary(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/u1.py b/torchquantum/operator/standard_gates/u1.py index e29728f1..5d22f53c 100644 --- a/torchquantum/operator/standard_gates/u1.py +++ b/torchquantum/operator/standard_gates/u1.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class U1(DiagonalOperation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/u2.py b/torchquantum/operator/standard_gates/u2.py index bd22c777..29a65aa8 100644 --- a/torchquantum/operator/standard_gates/u2.py +++ b/torchquantum/operator/standard_gates/u2.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class U2(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/u3.py b/torchquantum/operator/standard_gates/u3.py index 62279194..554c51ce 100644 --- a/torchquantum/operator/standard_gates/u3.py +++ b/torchquantum/operator/standard_gates/u3.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class U3(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/xx_min_yy.py b/torchquantum/operator/standard_gates/xx_min_yy.py index 5a5e4b00..4b225601 100644 --- a/torchquantum/operator/standard_gates/xx_min_yy.py +++ b/torchquantum/operator/standard_gates/xx_min_yy.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class XXMINYY(Operation, metaclass=ABCMeta): diff --git a/torchquantum/operator/standard_gates/xx_plus_yy.py b/torchquantum/operator/standard_gates/xx_plus_yy.py index 68de1c7b..575ae3ca 100644 --- a/torchquantum/operator/standard_gates/xx_plus_yy.py +++ b/torchquantum/operator/standard_gates/xx_plus_yy.py @@ -4,7 +4,7 @@ import torchquantum as tq import torch from torchquantum.functional import mat_dict -import torchquantum.functional.functionals as tqf +import torchquantum.functional as tqf class XXPLUSYY(Operation, metaclass=ABCMeta): From be369f05b470489a35c0b4d0381debebdd8c2562 Mon Sep 17 00:00:00 2001 From: Zhuoyang Ye Date: Fri, 12 Jan 2024 18:27:40 -0800 Subject: [PATCH 068/106] Fix some bug in density matrix calculation --- torchquantum/density/density_func.py | 4 +- torchquantum/density/density_mat.py | 119 ++++----------------------- torchquantum/density/test.py | 16 ++++ 3 files changed, 33 insertions(+), 106 deletions(-) create mode 100644 torchquantum/density/test.py diff --git a/torchquantum/density/density_func.py b/torchquantum/density/density_func.py index efcea462..92207790 100644 --- a/torchquantum/density/density_func.py +++ b/torchquantum/density/density_func.py @@ -28,8 +28,8 @@ import torchquantum as tq from typing import Callable, Union, Optional, List, Dict -from .macro import C_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 -from .util.utils import pauli_eigs, diag +from ..macro import C_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 +from ..util.utils import pauli_eigs, diag from torchpack.utils.logging import logger from torchquantum.util import normalize_statevector diff --git a/torchquantum/density/density_mat.py b/torchquantum/density/density_mat.py index b7e42244..1e185358 100644 --- a/torchquantum/density/density_mat.py +++ b/torchquantum/density/density_mat.py @@ -28,10 +28,8 @@ import numpy as np import functools import torchquantum.functional as tqf -import torchquantum.Dfunc as dfunc -import torchquantum as tq -import copy -from torchquantum.states import QuantumState +import torchquantum.density.density_func as dfunc +import torchquantum as tqf from torchquantum.macro import C_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 from typing import Union, List, Iterable @@ -56,17 +54,13 @@ def __init__(self, n_wires: int, bsz: int = 1): _matrix = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) _matrix[0] = 1 + 0j _matrix = torch.reshape(_matrix, [2] * (2 * self.n_wires)) + self._dims=2*self.n_wires self.register_buffer("matrix", _matrix) repeat_times = [bsz] + [1] * len(self.matrix.shape) self._matrix = self.matrix.repeat(*repeat_times) self.register_buffer("matrix", self._matrix) - """ - Whether or not calculate by states - """ - self._calc_by_states = True - """ Remember whether or not a standard matrix on a given wire is contructed """ @@ -81,34 +75,14 @@ def __init__(self, n_wires: int, bsz: int = 1): for key in tqf.func_name_dict.keys(): self.operator_matrix[key] = {} - """ - Preserve the probability of all pure states. has the form [(p1,s1),(p2,s2),(p3,s3),...] - 2**n 2**n 2**n - Matrix 3 purestate - """ - self.state_list = [] - for i in range(0, bsz): - self.state_list.append((1, QuantumState(n_wires))) - - def set_calc_by_states(self, val): - """Set the value of the `_calc_by_states` attribute. - - This method sets the flag that determines whether calculations should be performed using individual pure states or the density matrix. - - Args: - val (bool): The new value for the `_calc_by_states` attribute. + def update_matrix(self,matrix): + self._matrix=matrix + return - Returns: - None - Examples: - >>> device = QuantumDevice(n_wires=3) - >>> device.set_calc_by_states(True) - >>> device.calc_by_states - True - """ - - self._calc_by_states = val + @property + def dim(self): + return self._dims def update_matrix_from_states(self): """Update the density matrix value from all pure states. @@ -146,7 +120,7 @@ def vector(self): tensor([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) """ - return torch.reshape(_matrix, [2 ** (2 * self.n_wires)]) + return torch.reshape(self._matrix, [2 ** (2 * self.n_wires)]) def print_2d(self, index): """Print the matrix value at the given index. @@ -187,8 +161,8 @@ def trace(self, index): >>> device.trace(0) tensor(2) """ - - return torch.trace(self._matrix[index]) + _matrix = torch.reshape(self._matrix[index], [2**self.n_wires] * 2) + return torch.trace(_matrix) def positive_semidefinite(self, index): """Check whether the matrix is positive semidefinite by Sylvester's_criterion""" @@ -201,18 +175,6 @@ def check_valid(self): return False return True - def spectral(self, index): - """Return the spectral of the DensityMatrix""" - return list(np.linalg.eigvals(self._matrix[index])) - - def tensor(self, other): - """Return self tensor other(Notice the order) - - Args: - other (DensityMatrix: Another density matrix - """ - self._matrix = torch.kron(self._matrix, other._matrix) - def expand(self, other): """Return other tensor self(Notice the order) @@ -255,59 +217,6 @@ def expectation(self): """Expectation of a measurement""" return - def set_from_state(self, probs, states: Union[torch.Tensor, List]): - """Get the density matrix of a mixed state. - - Args: - probs:List of probability of each state - states:List of state. - - Examples: - probs:[0.5,0.5],states:[|00>,|11>] - Then the corresponding matrix is: 0.5|00><00|+0.5|11><11| - 0.5, 0, 0, 0 - 0 , 0, 0, 0 - 0 , 0, 0, 0 - 0 , 0, 0, 0.5 - self._matrix[00][00]=self._matrix[11][11]=0.5 - """ - - for i in range(0, len(probs)): - self.state_list - _matrix = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) - _matrix = torch.reshape(_matrix, [2**self.n_wires, 2**self.n_wires]) - for i in range(0, len(probs)): - row = torch.reshape(states[i], [2**self.n_wires, 1]) - col = torch.reshape(states[i], [1, 2**self.n_wires]) - _matrix = _matrix + probs[i] * torch.matmul(row, col) - self.matrix = torch.reshape(_matrix, [2] * (2 * self.n_wires)) - return - - def _add(self, other): - """Return self + other - - Args: - other (complex): a complex number. - """ - - if not isinstance(other, DensityMatrix): - other = DensityMatrix(other) - if not self._matrix.shape == other._matrix.shape: - raise ("Two density matrix must have the same shape.") - ret = copy.copy(self) - ret._matrix = self.matrix + other._matrix - return ret - - def _multiply(self, other): - """Return other * self. - - Args: - other (complex): a complex number. - """ - - ret = copy.copy(self) - ret._matrix = other * self._matrix - return ret def purity(self): """Calculate the purity of the DensityMatrix defined as \gamma=tr(\rho^2)""" @@ -323,13 +232,15 @@ def partial_trace(self, dims: List[int]): First, the matrix should be reshped to (2,2,2,2,2,2) then we call np.einsum('ijiiqi->jq', reshaped_dm) """ - return False @property def name(self): return self.__class__.__name__ + + + def __repr__(self): return f"Density Matrix" diff --git a/torchquantum/density/test.py b/torchquantum/density/test.py new file mode 100644 index 00000000..f005f7a5 --- /dev/null +++ b/torchquantum/density/test.py @@ -0,0 +1,16 @@ +from torchquantum.density import density_mat +from torchquantum.density import density_func + + + + +if __name__ == "__main__": + mat = density_func.mat_dict["hadamard"] + print(mat) + D = density_mat.DensityMatrix(2) + D.print_2d(0) + newD=density_func.apply_unitary_density_bmm(D._matrix,mat,[0]) + + D.update_matrix(newD) + + D.print_2d(0) From 78a16d77fdd708639d3ab0d67ffb86eca2922e9e Mon Sep 17 00:00:00 2001 From: Zhuoyang Ye Date: Fri, 19 Jan 2024 17:47:52 -0800 Subject: [PATCH 069/106] The bell example of density matrix multiplication is correct. --- torchquantum/density/density_func.py | 886 +++++++++++++-------------- torchquantum/density/density_mat.py | 505 ++++++++------- torchquantum/density/test.py | 21 +- 3 files changed, 699 insertions(+), 713 deletions(-) diff --git a/torchquantum/density/density_func.py b/torchquantum/density/density_func.py index 92207790..842c28c9 100644 --- a/torchquantum/density/density_func.py +++ b/torchquantum/density/density_func.py @@ -113,7 +113,7 @@ def apply_unitary_density_einsum(density, mat, wires): Returns: torch.Tensor: The new statevector. """ - + device_wires = wires n_qubit = int((density.dim() - 1) / 2) @@ -151,7 +151,7 @@ def apply_unitary_density_einsum(density, mat, wires): # All affected indices will be summed over, so we need the same number # of new indices - new_indices = ABC[total_wires : total_wires + len(device_wires)] + new_indices = ABC[total_wires: total_wires + len(device_wires)] print("new_indices", new_indices) # The new indices of the state are given by the old ones with the @@ -195,7 +195,7 @@ def apply_unitary_density_einsum(density, mat, wires): # All affected indices will be summed over, so we need the same number # of new indices - new_indices = ABC[total_wires : total_wires + len(device_wires)] + new_indices = ABC[total_wires: total_wires + len(device_wires)] print("new_indices", new_indices) # The new indices of the state are given by the old ones with the @@ -230,14 +230,11 @@ def apply_unitary_density_bmm(density, mat, wires): state (torch.Tensor): The statevector. mat (torch.Tensor): The unitary matrix of the operation. wires (int or List[int]): Which qubit the operation is applied to. - Returns: torch.Tensor: The new statevector. """ - device_wires = wires - n_qubit = int((density.dim() - 1) / 2) - + n_qubit = density.dim() // 2 mat = mat.type(C_DTYPE).to(density.device) """ Compute U \rho @@ -249,9 +246,8 @@ def apply_unitary_density_bmm(density, mat, wires): permute_to = permute_to[:1] + devices_dims + permute_to[1:] permute_back = list(np.argsort(permute_to)) original_shape = density.shape - permuted = density.permute(permute_to).reshape( - [original_shape[0], mat.shape[-1], -1] - ) + permuted = density.permute(permute_to).reshape([original_shape[0], mat.shape[-1], -1]) + if len(mat.shape) > 2: # both matrix and state are in batch mode new_density = mat.bmm(permuted) @@ -261,45 +257,45 @@ def apply_unitary_density_bmm(density, mat, wires): expand_shape = [bsz] + list(mat.shape) new_density = mat.expand(expand_shape).bmm(permuted) new_density = new_density.view(original_shape).permute(permute_back) + _matrix = torch.reshape(new_density[0], [2 ** n_qubit] * 2) """ - Compute U*rho*U^\dagger + Compute \rho U^\dagger """ - devices_dims = [w + 1 + n_qubit for w in device_wires] - permute_to = list(range(density.dim())) - for d in sorted(devices_dims, reverse=True): - del permute_to[d] - permute_to = permute_to + devices_dims - permute_back = list(np.argsort(permute_to)) - original_shape = density.shape - permuted = new_density.permute(permute_to).reshape( - [original_shape[0], -1, mat.shape[-1]] - ) - if len(mat.shape) > 2: + matdag = torch.conj(mat) + matdag = matdag.type(C_DTYPE).to(density.device) + + devices_dims_dag = [n_qubit + w + 1 for w in device_wires] + permute_to_dag = list(range(density.dim())) + for d in sorted(devices_dims_dag, reverse=True): + del permute_to_dag[d] + permute_to_dag = permute_to_dag + devices_dims_dag + permute_back_dag = list(np.argsort(permute_to_dag)) + original_shape = new_density.shape + permuted_dag = new_density.permute(permute_to_dag).reshape([original_shape[0], -1, matdag.shape[0]]) + + if len(matdag.shape) > 2: # both matrix and state are in batch mode - # matdag is the dagger of mat - matdag = torch.conj(mat.permute([0, 2, 1])) - new_density = permuted.bmm(matdag) + new_density = permuted_dag.bmm(matdag) else: # matrix no batch, state in batch mode - matdag = torch.conj(mat.permute([1, 0])) - bsz = permuted.shape[0] + bsz = permuted_dag.shape[0] expand_shape = [bsz] + list(matdag.shape) - new_density = permuted.bmm(matdag.expand(expand_shape)) - new_density = new_density.view(original_shape).permute(permute_back) + new_density =permuted_dag.bmm( matdag.expand(expand_shape)) + _matrix = torch.reshape(new_density[0], [2 ** n_qubit] * 2) return new_density def gate_wrapper( - name, - mat, - method, - q_device: tq.QuantumDevice, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, + name, + mat, + method, + q_device: tq.QuantumDevice, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, ): """Perform the phaseshift gate. @@ -325,7 +321,7 @@ def gate_wrapper( Returns: None. """ - + if params is not None: if not isinstance(params, torch.Tensor): # this is for qubitunitary gate @@ -440,7 +436,7 @@ def rx_matrix(params: torch.Tensor) -> torch.Tensor: Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) """ Seems to be a pytorch bug. Have to explicitly cast the theta to a @@ -452,7 +448,7 @@ def rx_matrix(params: torch.Tensor) -> torch.Tensor: (Could this error message be improved? If so, please report an enhancement request to PyTorch.) """ - + co = torch.cos(theta / 2) jsi = 1j * torch.sin(-theta / 2) @@ -470,7 +466,7 @@ def ry_matrix(params: torch.Tensor) -> torch.Tensor: Returns: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) co = torch.cos(theta / 2) @@ -490,7 +486,7 @@ def rz_matrix(params: torch.Tensor) -> torch.Tensor: Returns: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) exp = torch.exp(-0.5j * theta) @@ -550,7 +546,7 @@ def rot_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) theta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) omega = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) @@ -588,7 +584,7 @@ def multirz_eigvals(params, n_wires): Returns: torch.Tensor: The computed eigenvalues. """ - + theta = params.type(C_DTYPE) return torch.exp( -1j * theta / 2 * torch.tensor(pauli_eigs(n_wires)).to(params.device) @@ -604,7 +600,7 @@ def multirz_matrix(params, n_wires): Returns: torch.Tensor: The computed unitary matrix. """ - + # torch diagonal not available for complex number eigvals = multirz_eigvals(params, n_wires) dia = diag(eigvals) @@ -657,7 +653,7 @@ def ryy_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) co = torch.cos(theta / 2) jsi = 1j * torch.sin(theta / 2) @@ -694,7 +690,7 @@ def rzz_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) exp = torch.exp(-0.5j * theta) conj_exp = torch.conj(exp) @@ -726,7 +722,7 @@ def rzx_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) co = torch.cos(theta / 2) jsi = 1j * torch.sin(theta / 2) @@ -796,7 +792,7 @@ def cry_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) co = torch.cos(theta / 2) si = torch.sin(theta / 2) @@ -827,7 +823,7 @@ def crz_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) exp = torch.exp(-0.5j * theta) @@ -855,7 +851,7 @@ def crot_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + phi = params[:, 0].type(C_DTYPE) theta = params[:, 1].type(C_DTYPE) omega = params[:, 2].type(C_DTYPE) @@ -890,7 +886,7 @@ def u1_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + phi = params.type(C_DTYPE) exp = torch.exp(1j * phi) @@ -918,7 +914,7 @@ def cu1_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + phi = params.type(C_DTYPE) exp = torch.exp(1j * phi) @@ -946,7 +942,7 @@ def u2_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) @@ -971,7 +967,7 @@ def cu2_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) @@ -1001,7 +997,7 @@ def u3_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) @@ -1029,7 +1025,7 @@ def cu3_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) @@ -1067,7 +1063,7 @@ def qubitunitary_matrix(params): Raises: AssertionError: If Operator is other than square matrix """ - + matrix = params.squeeze(0) try: assert matrix.shape[-1] == matrix.shape[-2] @@ -1107,7 +1103,7 @@ def qubitunitaryfast_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + return params.squeeze(0) @@ -1121,7 +1117,7 @@ def qubitunitarystrict_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + params.squeeze(0) mat = params U, Sigma, V = torch.svd(mat) @@ -1137,8 +1133,8 @@ def multicnot_matrix(n_wires): Returns: torch.Tensor: The computed unitary matrix. """ - - mat = torch.eye(2**n_wires, dtype=C_DTYPE) + + mat = torch.eye(2 ** n_wires, dtype=C_DTYPE) mat[-1][-1] = 0 mat[-2][-2] = 0 mat[-1][-2] = 1 @@ -1156,9 +1152,9 @@ def multixcnot_matrix(n_wires): Returns: torch.Tensor: The computed unitary matrix. """ - + # when all control qubits are zero, then the target qubit will flip - mat = torch.eye(2**n_wires, dtype=C_DTYPE) + mat = torch.eye(2 ** n_wires, dtype=C_DTYPE) mat[0][0] = 0 mat[1][1] = 0 mat[0][1] = 1 @@ -1176,7 +1172,7 @@ def single_excitation_matrix(params): Returns: torch.Tensor: The computed unitary matrix. """ - + theta = params.type(C_DTYPE) co = torch.cos(theta / 2) si = torch.sin(theta / 2) @@ -1294,14 +1290,14 @@ def single_excitation_matrix(params): def hadamard( - q_device: tq.QuantumDevice, - wires: Union[List[int], int], - params: torch.Tensor = None, - n_wires: int = None, - static: bool = False, - parent_graph=None, - inverse: bool = False, - comp_method: str = "bmm", + q_device: tq.QuantumDevice, + wires: Union[List[int], int], + params: torch.Tensor = None, + n_wires: int = None, + static: bool = False, + parent_graph=None, + inverse: bool = False, + comp_method: str = "bmm", ): """Perform the hadamard gate. @@ -1323,7 +1319,7 @@ def hadamard( Returns: None. """ - + name = "hadamard" mat = mat_dict[name] gate_wrapper( @@ -1341,14 +1337,14 @@ def hadamard( def shadamard( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the shadamard gate. @@ -1370,7 +1366,7 @@ def shadamard( Returns: None. """ - + name = "shadamard" mat = mat_dict[name] gate_wrapper( @@ -1388,14 +1384,14 @@ def shadamard( def paulix( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the Pauli X gate. @@ -1417,7 +1413,7 @@ def paulix( Returns: None. """ - + name = "paulix" mat = mat_dict[name] gate_wrapper( @@ -1435,14 +1431,14 @@ def paulix( def pauliy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the Pauli Y gate. @@ -1464,7 +1460,7 @@ def pauliy( Returns: None. """ - + name = "pauliy" mat = mat_dict[name] gate_wrapper( @@ -1482,14 +1478,14 @@ def pauliy( def pauliz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the Pauli Z gate. @@ -1511,7 +1507,7 @@ def pauliz( Returns: None. """ - + name = "pauliz" mat = mat_dict[name] gate_wrapper( @@ -1529,14 +1525,14 @@ def pauliz( def i( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the I gate. @@ -1558,7 +1554,7 @@ def i( Returns: None. """ - + name = "i" mat = mat_dict[name] gate_wrapper( @@ -1576,14 +1572,14 @@ def i( def s( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the s gate. @@ -1605,7 +1601,7 @@ def s( Returns: None. """ - + name = "s" mat = mat_dict[name] gate_wrapper( @@ -1623,14 +1619,14 @@ def s( def t( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the t gate. @@ -1652,7 +1648,7 @@ def t( Returns: None. """ - + name = "t" mat = mat_dict[name] gate_wrapper( @@ -1670,14 +1666,14 @@ def t( def sx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the sx gate. @@ -1699,7 +1695,7 @@ def sx( Returns: None. """ - + name = "sx" mat = mat_dict[name] gate_wrapper( @@ -1717,14 +1713,14 @@ def sx( def cnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cnot gate. @@ -1746,7 +1742,7 @@ def cnot( Returns: None. """ - + name = "cnot" mat = mat_dict[name] gate_wrapper( @@ -1764,14 +1760,14 @@ def cnot( def cz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cz gate. @@ -1793,7 +1789,7 @@ def cz( Returns: None. """ - + name = "cz" mat = mat_dict[name] gate_wrapper( @@ -1811,14 +1807,14 @@ def cz( def cy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cy gate. @@ -1840,7 +1836,7 @@ def cy( Returns: None. """ - + name = "cy" mat = mat_dict[name] gate_wrapper( @@ -1858,14 +1854,14 @@ def cy( def rx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the rx gate. @@ -1887,7 +1883,7 @@ def rx( Returns: None. """ - + name = "rx" mat = mat_dict[name] gate_wrapper( @@ -1905,14 +1901,14 @@ def rx( def ry( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the ry gate. @@ -1934,7 +1930,7 @@ def ry( Returns: None. """ - + name = "ry" mat = mat_dict[name] gate_wrapper( @@ -1952,14 +1948,14 @@ def ry( def rz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the rz gate. @@ -1981,7 +1977,7 @@ def rz( Returns: None. """ - + name = "rz" mat = mat_dict[name] gate_wrapper( @@ -1999,14 +1995,14 @@ def rz( def rxx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the rxx gate. @@ -2028,7 +2024,7 @@ def rxx( Returns: None. """ - + name = "rxx" mat = mat_dict[name] gate_wrapper( @@ -2046,14 +2042,14 @@ def rxx( def ryy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the ryy gate. @@ -2075,7 +2071,7 @@ def ryy( Returns: None. """ - + name = "ryy" mat = mat_dict[name] gate_wrapper( @@ -2093,14 +2089,14 @@ def ryy( def rzz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the rzz gate. @@ -2122,7 +2118,7 @@ def rzz( Returns: None. """ - + name = "rzz" mat = mat_dict[name] gate_wrapper( @@ -2140,14 +2136,14 @@ def rzz( def rzx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the rzx gate. @@ -2169,7 +2165,7 @@ def rzx( Returns: None. """ - + name = "rzx" mat = mat_dict[name] gate_wrapper( @@ -2187,14 +2183,14 @@ def rzx( def swap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the swap gate. @@ -2216,7 +2212,7 @@ def swap( Returns: None. """ - + name = "swap" mat = mat_dict[name] gate_wrapper( @@ -2234,14 +2230,14 @@ def swap( def sswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the sswap gate. @@ -2263,7 +2259,7 @@ def sswap( Returns: None. """ - + name = "sswap" mat = mat_dict[name] gate_wrapper( @@ -2281,14 +2277,14 @@ def sswap( def cswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cswap gate. @@ -2310,7 +2306,7 @@ def cswap( Returns: None. """ - + name = "cswap" mat = mat_dict[name] gate_wrapper( @@ -2328,14 +2324,14 @@ def cswap( def toffoli( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the toffoli gate. @@ -2357,7 +2353,7 @@ def toffoli( Returns: None. """ - + name = "toffoli" mat = mat_dict[name] gate_wrapper( @@ -2375,14 +2371,14 @@ def toffoli( def phaseshift( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the phaseshift gate. @@ -2404,7 +2400,7 @@ def phaseshift( Returns: None. """ - + name = "phaseshift" mat = mat_dict[name] gate_wrapper( @@ -2422,14 +2418,14 @@ def phaseshift( def rot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the rot gate. @@ -2451,7 +2447,7 @@ def rot( Returns: None. """ - + name = "rot" mat = mat_dict[name] gate_wrapper( @@ -2469,14 +2465,14 @@ def rot( def multirz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the multi qubit RZ gate. @@ -2498,7 +2494,7 @@ def multirz( Returns: None. """ - + name = "multirz" mat = mat_dict[name] gate_wrapper( @@ -2516,14 +2512,14 @@ def multirz( def crx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the crx gate. @@ -2545,7 +2541,7 @@ def crx( Returns: None. """ - + name = "crx" mat = mat_dict[name] gate_wrapper( @@ -2563,14 +2559,14 @@ def crx( def cry( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cry gate. @@ -2592,7 +2588,7 @@ def cry( Returns: None. """ - + name = "cry" mat = mat_dict[name] gate_wrapper( @@ -2610,14 +2606,14 @@ def cry( def crz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the crz gate. @@ -2639,7 +2635,7 @@ def crz( Returns: None. """ - + name = "crz" mat = mat_dict[name] gate_wrapper( @@ -2657,14 +2653,14 @@ def crz( def crot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the crot gate. @@ -2686,7 +2682,7 @@ def crot( Returns: None. """ - + name = "crot" mat = mat_dict[name] gate_wrapper( @@ -2704,14 +2700,14 @@ def crot( def u1( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the u1 gate. @@ -2733,7 +2729,7 @@ def u1( Returns: None. """ - + name = "u1" mat = mat_dict[name] gate_wrapper( @@ -2751,14 +2747,14 @@ def u1( def u2( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the u2 gate. @@ -2780,7 +2776,7 @@ def u2( Returns: None. """ - + name = "u2" mat = mat_dict[name] gate_wrapper( @@ -2798,14 +2794,14 @@ def u2( def u3( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the u3 gate. @@ -2827,7 +2823,7 @@ def u3( Returns: None. """ - + name = "u3" mat = mat_dict[name] gate_wrapper( @@ -2845,14 +2841,14 @@ def u3( def cu1( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cu1 gate. @@ -2874,7 +2870,7 @@ def cu1( Returns: None. """ - + name = "cu1" mat = mat_dict[name] gate_wrapper( @@ -2892,14 +2888,14 @@ def cu1( def cu2( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cu2 gate. @@ -2921,7 +2917,7 @@ def cu2( Returns: None. """ - + name = "cu2" mat = mat_dict[name] gate_wrapper( @@ -2939,14 +2935,14 @@ def cu2( def cu3( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the cu3 gate. @@ -2968,7 +2964,7 @@ def cu3( Returns: None. """ - + name = "cu3" mat = mat_dict[name] gate_wrapper( @@ -2986,14 +2982,14 @@ def cu3( def qubitunitary( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the qubitunitary gate. @@ -3015,7 +3011,7 @@ def qubitunitary( Returns: None. """ - + name = "qubitunitary" mat = mat_dict[name] gate_wrapper( @@ -3033,14 +3029,14 @@ def qubitunitary( def qubitunitaryfast( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the qubitunitaryfast gate. @@ -3062,7 +3058,7 @@ def qubitunitaryfast( Returns: None. """ - + name = "qubitunitaryfast" mat = mat_dict[name] gate_wrapper( @@ -3080,14 +3076,14 @@ def qubitunitaryfast( def qubitunitarystrict( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the qubitunitarystrict = gate. @@ -3109,7 +3105,7 @@ def qubitunitarystrict( Returns: None. """ - + name = "qubitunitarystrict" mat = mat_dict[name] gate_wrapper( @@ -3127,14 +3123,14 @@ def qubitunitarystrict( def multicnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the multi qubit cnot gate. @@ -3156,7 +3152,7 @@ def multicnot( Returns: None. """ - + name = "multicnot" mat = mat_dict[name] gate_wrapper( @@ -3174,14 +3170,14 @@ def multicnot( def multixcnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the multi qubit xcnot gate. @@ -3203,7 +3199,7 @@ def multixcnot( Returns: None. """ - + name = "multixcnot" mat = mat_dict[name] gate_wrapper( @@ -3221,14 +3217,14 @@ def multixcnot( def single_excitation( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", + q_device, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, + comp_method="bmm", ): """Perform the single excitation gate. @@ -3250,7 +3246,7 @@ def single_excitation( Returns: None. """ - + name = "single_excitation" mat = mat_dict[name] gate_wrapper( diff --git a/torchquantum/density/density_mat.py b/torchquantum/density/density_mat.py index 1e185358..8260a01b 100644 --- a/torchquantum/density/density_mat.py +++ b/torchquantum/density/density_mat.py @@ -33,7 +33,6 @@ from torchquantum.macro import C_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 from typing import Union, List, Iterable - __all__ = ["DensityMatrix"] @@ -54,7 +53,7 @@ def __init__(self, n_wires: int, bsz: int = 1): _matrix = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) _matrix[0] = 1 + 0j _matrix = torch.reshape(_matrix, [2] * (2 * self.n_wires)) - self._dims=2*self.n_wires + self._dims = 2 * self.n_wires self.register_buffer("matrix", _matrix) repeat_times = [bsz] + [1] * len(self.matrix.shape) @@ -75,35 +74,19 @@ def __init__(self, n_wires: int, bsz: int = 1): for key in tqf.func_name_dict.keys(): self.operator_matrix[key] = {} - def update_matrix(self,matrix): - self._matrix=matrix + def update_matrix(self, matrix): + bsz = self._matrix.shape[0] + self._matrix = matrix + self.register_buffer("matrix", matrix) + repeat_times = [bsz] + [1] * len(self.matrix.shape) + self._matrix = self.matrix.repeat(*repeat_times) + self.register_buffer("matrix", self._matrix) return - @property def dim(self): return self._dims - def update_matrix_from_states(self): - """Update the density matrix value from all pure states. - - This method updates the density matrix value based on all the pure states in the state list. - - Returns: - None - """ - - _matrix = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) - _matrix = torch.reshape(_matrix, [2**self.n_wires, 2**self.n_wires]) - self.register_buffer("matrix", _matrix) - bsz = self.matrix.shape[0] - repeat_times = [bsz] + [1] * len(self.matrix.shape) - self._matrix = self.matrix.repeat(*repeat_times) - for i in range(0, bsz): - for p, state in self.state_list: - self._matrix[i] = self._matrix[i] + p * state.density_matrix()[0][:][:] - self.register_buffer("matrix", self._matrix) - def vector(self): """Return the density matrix as a vector. @@ -119,7 +102,7 @@ def vector(self): >>> print(vector) tensor([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) """ - + return torch.reshape(self._matrix, [2 ** (2 * self.n_wires)]) def print_2d(self, index): @@ -139,8 +122,8 @@ def print_2d(self, index): [0, 1]]) """ - - _matrix = torch.reshape(self._matrix[index], [2**self.n_wires] * 2) + + _matrix = torch.reshape(self._matrix[index], [2 ** self.n_wires] * 2) print(_matrix) def trace(self, index): @@ -161,7 +144,7 @@ def trace(self, index): >>> device.trace(0) tensor(2) """ - _matrix = torch.reshape(self._matrix[index], [2**self.n_wires] * 2) + _matrix = torch.reshape(self._matrix[index], [2 ** self.n_wires] * 2) return torch.trace(_matrix) def positive_semidefinite(self, index): @@ -189,7 +172,7 @@ def clone_matrix(self, existing_matrix: torch.Tensor): def set_matrix(self, matrix: Union[torch.tensor, List]): """ """ - + matrix = torch.tensor(matrix, dtype=C_DTYPE).to(self.matrix.device) bsz = matrix.shape[0] self.matrix = torch.reshape( @@ -210,14 +193,13 @@ def evolve(self, operator): torch.reshape(self.matrix, [bsz, 2 ** (2 * self.n_wires)]) ) self.matrix = torch.reshape( - new_matrix, [bsz, 2**self.n_wires, 2**self.n_wires] + new_matrix, [bsz, 2 ** self.n_wires, 2 ** self.n_wires] ) def expectation(self): """Expectation of a measurement""" return - def purity(self): """Calculate the purity of the DensityMatrix defined as \gamma=tr(\rho^2)""" return torch.trace(torch.matmul(self._matrix, self._matrix)) @@ -238,17 +220,14 @@ def partial_trace(self, dims: List[int]): def name(self): return self.__class__.__name__ - - - def __repr__(self): return f"Density Matrix" def hadamard( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a Hadamard gate on the specified wires. @@ -276,10 +255,10 @@ def hadamard( dfunc.hadamard(self, wires=wires, inverse=inverse, comp_method=comp_method) def shadamard( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a SHadamard gate (square root of Hadamard gate) on the specified wires. @@ -307,10 +286,10 @@ def shadamard( dfunc.shadamard(self, wires=wires, inverse=inverse, comp_method=comp_method) def paulix( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a Pauli-X gate (also known as the NOT gate) on the specified wires. @@ -335,14 +314,14 @@ def paulix( >>> device = QuantumDevice(n_wires=2) >>> device.paulix(wires=[0, 1], inverse=False) """ - + dfunc.paulix(self, wires=wires, inverse=inverse, comp_method=comp_method) def pauliy( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a Pauli-Y gate on the specified wires. @@ -367,14 +346,14 @@ def pauliy( >>> device = QuantumDevice(n_wires=2) >>> device.pauliy(wires=[0, 1], inverse=False) """ - + dfunc.pauliy(self, wires=wires, inverse=inverse, comp_method=comp_method) def pauliz( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a Pauli-Z gate on the specified wires. @@ -402,10 +381,10 @@ def pauliz( dfunc.pauliz(self, wires=wires, inverse=inverse, comp_method=comp_method) def i( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply an identity gate on the specified wires. @@ -430,14 +409,14 @@ def i( >>> device = QuantumDevice(n_wires=2) >>> device.i(wires=[0, 1], inverse=False) """ - + dfunc.i(self, wires=wires, inverse=inverse, comp_method=comp_method) def s( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply an S gate on the specified wires. @@ -462,14 +441,14 @@ def s( >>> device = QuantumDevice(n_wires=2) >>> device.s(wires=[0, 1], inverse=False) """ - + dfunc.s(self, wires=wires, inverse=inverse, comp_method=comp_method) def t( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a T gate on the specified wires. @@ -493,14 +472,14 @@ def t( >>> device = QuantumDevice(n_wires=2) >>> device.t(wires=[0, 1], inverse=False) """ - + dfunc.t(self, wires=wires, inverse=inverse, comp_method=comp_method) def sx( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a SX gate (square root of Pauli-X gate) on the specified wires. @@ -525,14 +504,14 @@ def sx( >>> device = QuantumDevice(n_wires=2) >>> device.sx(wires=[0, 1], inverse=False) """ - + dfunc.sx(self, wires=wires, inverse=inverse, comp_method=comp_method) def cnot( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-NOT (CNOT) gate on the specified wires. @@ -557,14 +536,14 @@ def cnot( >>> device = QuantumDevice(n_wires=2) >>> device.cnot(wires=[0, 1], inverse=False) """ - + dfunc.cnot(self, wires=wires, inverse=inverse, comp_method=comp_method) def cz( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-Z (CZ) gate on the specified wires. @@ -589,14 +568,14 @@ def cz( >>> device = QuantumDevice(n_wires=3) >>> device.cz(wires=[0, 1], inverse=False) """ - + dfunc.cz(self, wires=wires, inverse=inverse, comp_method=comp_method) def cy( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-Y (CY) gate on the specified wires. @@ -621,14 +600,14 @@ def cy( >>> device = QuantumDevice(n_wires=3) >>> device.cy(wires=[0, 1], inverse=False) """ - + dfunc.cy(self, wires=wires, inverse=inverse, comp_method=comp_method) def swap( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a swap gate on the specified wires. @@ -653,14 +632,14 @@ def swap( >>> device = QuantumDevice(n_wires=3) >>> device.swap(wires=[0, 1, 2], inverse=False) """ - + dfunc.swap(self, wires=wires, inverse=inverse, comp_method=comp_method) def sswap( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a symmetric swap gate on the specified wires. @@ -685,14 +664,14 @@ def sswap( >>> device = QuantumDevice(n_wires=3) >>> device.sswap(wires=[0, 1, 2], inverse=False) """ - + dfunc.sswap(self, wires=wires, inverse=inverse, comp_method=comp_method) def cswap( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled swap (Fredkin) gate on the specified wires. @@ -717,14 +696,14 @@ def cswap( >>> device = QuantumDevice(n_wires=3) >>> device.cswap(wires=[0, 1, 2], inverse=False) """ - + dfunc.cswap(self, wires=wires, inverse=inverse, comp_method=comp_method) def toffoli( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a Toffoli (CCNOT) gate on the specified wires. @@ -749,14 +728,14 @@ def toffoli( >>> device = QuantumDevice(n_wires=3) >>> device.toffoli(wires=[0, 1, 2], inverse=False) """ - + dfunc.toffoli(self, wires=wires, inverse=inverse, comp_method=comp_method) def multicnot( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a multi-qubit controlled-NOT (CNOT) gate on the specified wires. @@ -782,14 +761,14 @@ def multicnot( >>> device = QuantumDevice(n_wires=3) >>> device.multicnot(wires=[0, 1, 2], inverse=False) """ - + dfunc.multicnot(self, wires=wires, inverse=inverse, comp_method=comp_method) def multixcnot( - self, - wires: Union[List[int], int], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a multi-qubit X gate or CNOT gate on the specified wires. @@ -815,15 +794,15 @@ def multixcnot( >>> device = QuantumDevice(n_wires=3) >>> device.multixcnot(wires=[0, 1, 2], inverse=False) """ - + dfunc.multixcnot(self, wires=wires, inverse=inverse, comp_method=comp_method) def rx( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a single-qubit Rx gate on the specified wires. @@ -851,7 +830,7 @@ def rx( >>> params = torch.tensor(0.5) >>> device.rx(wires=0, params=params) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -862,11 +841,11 @@ def rx( ) def ry( - self, - wires: Union[List[int], int], - params: torch.Tensor, - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: torch.Tensor, + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a single-qubit Ry gate on the specified wires. @@ -893,7 +872,7 @@ def ry( >>> params = torch.tensor(0.5) >>> device.ry(wires=0, params=params) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -904,11 +883,11 @@ def ry( ) def rz( - self, - wires: Union[List[int], int], - params: torch.Tensor, - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: torch.Tensor, + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a single-qubit Rz gate on the specified wires. @@ -935,7 +914,7 @@ def rz( >>> params = torch.tensor(0.5) >>> device.rz(wires=0, params=params) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -946,11 +925,11 @@ def rz( ) def rxx( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a rotation XX gate on the specified wires. @@ -978,7 +957,7 @@ def rxx( >>> device = QuantumDevice(n_wires=2) >>> device.rxx(wires=[0, 1], params=0.1) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -989,11 +968,11 @@ def rxx( ) def ryy( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a rotation YY gate on the specified wires. @@ -1021,7 +1000,7 @@ def ryy( >>> device = QuantumDevice(n_wires=2) >>> device.rzz(wires=[0, 1], params=0.1) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1032,11 +1011,11 @@ def ryy( ) def rzz( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a rotation ZZ gate on the specified wires. @@ -1064,7 +1043,7 @@ def rzz( >>> device = QuantumDevice(n_wires=2) >>> device.rzz(wires=[0, 1], params=0.3) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1075,11 +1054,11 @@ def rzz( ) def rzx( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled Rz gate on the specified wires. @@ -1107,7 +1086,7 @@ def rzx( >>> device = QuantumDevice(n_wires=3) >>> device.rzx(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1118,11 +1097,11 @@ def rzx( ) def phaseshift( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a phase shift gate on the specified wires. @@ -1150,7 +1129,7 @@ def phaseshift( >>> device = QuantumDevice(n_wires=2) >>> device.phaseshift(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1161,11 +1140,11 @@ def phaseshift( ) def rot( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a rotation gate on the specified wires. @@ -1193,7 +1172,7 @@ def rot( >>> device = QuantumDevice(n_wires=2) >>> device.rot(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1207,11 +1186,11 @@ def rot( ) def multirz( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a multi-controlled Z-rotation gate on the specified control wires. @@ -1250,11 +1229,11 @@ def multirz( ) def crx( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled X-rotation gate on the specified control and target wires. @@ -1282,7 +1261,7 @@ def crx( >>> device = QuantumDevice(n_wires=2) >>> device.crx(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1293,11 +1272,11 @@ def crx( ) def cry( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled Y-rotation gate on the specified control and target wires. @@ -1325,7 +1304,7 @@ def cry( >>> device = QuantumDevice(n_wires=2) >>> device.cry(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1336,11 +1315,11 @@ def cry( ) def crz( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled phase rotation gate on the specified control and target wires. @@ -1368,7 +1347,7 @@ def crz( >>> device = QuantumDevice(n_wires=2) >>> device.crz(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1379,11 +1358,11 @@ def crz( ) def crot( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-rotation gate on the specified control and target wires. @@ -1411,7 +1390,7 @@ def crot( >>> device = QuantumDevice(n_wires=2) >>> device.crot(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1425,11 +1404,11 @@ def crot( ) def u1( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a u1 gate on the specified wires. @@ -1457,7 +1436,7 @@ def u1( >>> device = QuantumDevice(n_wires=2) >>> device.u1(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1468,11 +1447,11 @@ def u1( ) def u2( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a u2 gate on the specified wires. @@ -1500,7 +1479,7 @@ def u2( >>> device = QuantumDevice(n_wires=2) >>> device.u2(wires=[0, 1], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1514,11 +1493,11 @@ def u2( ) def u3( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a u3 gate on the specified wires. @@ -1560,11 +1539,11 @@ def u3( ) def cu1( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-u1 gate on the specified wires. @@ -1592,7 +1571,7 @@ def cu1( >>> device = QuantumDevice(n_wires=2) >>> device.cu1(wires=[0, 1], params=[0.3, 0.5]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1606,11 +1585,11 @@ def cu1( ) def cu2( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-u2 gate on the specified wires. @@ -1638,7 +1617,7 @@ def cu2( >>> device = QuantumDevice(n_wires=2) >>> device.cu2(wires=[0, 1], params=[0.3, 0.5]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: @@ -1652,11 +1631,11 @@ def cu2( ) def cu3( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a controlled-u3 gate on the specified wires. @@ -1698,11 +1677,11 @@ def cu3( ) def qubitunitary( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a unitary gate on the specified wires. @@ -1730,7 +1709,7 @@ def qubitunitary( >>> device = QuantumDevice(n_wires=3) >>> device.qubitunitary(wires=[0, 1], params=[0.5, 0.5]) """ - + if isinstance(params, Iterable): params = torch.tensor(params, dtype=C_DTYPE) else: @@ -1741,11 +1720,11 @@ def qubitunitary( ) def qubitunitaryfast( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a unitary gate on the specified wires (fast method). @@ -1774,7 +1753,7 @@ def qubitunitaryfast( >>> device = QuantumDevice(n_wires=3) >>> device.qubitunitaryfast(wires=[0, 1], params=[0.5, 0.5]) """ - + if isinstance(params, Iterable): params = torch.tensor(params, dtype=C_DTYPE) else: @@ -1785,11 +1764,11 @@ def qubitunitaryfast( ) def qubitunitarystrict( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): """Apply a unitary gate on the specified wires. @@ -1828,13 +1807,13 @@ def qubitunitarystrict( ) def single_excitation( - self, - wires: Union[List[int], int], - params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], - inverse: bool = False, - comp_method: str = "bmm", + self, + wires: Union[List[int], int], + params: Union[torch.Tensor, np.ndarray, List[float], List[int], int, float], + inverse: bool = False, + comp_method: str = "bmm", ): - + """Apply a single excitation gate on the specified wires. This method applies a single excitation gate on the specified wires of the quantum device. @@ -1860,7 +1839,7 @@ def single_excitation( >>> device = QuantumDevice(n_wires=3) >>> device.single_excitation(wires=[0, 2], params=[0.1, 0.2]) """ - + if isinstance(params, Iterable): params = torch.Tensor(params) else: diff --git a/torchquantum/density/test.py b/torchquantum/density/test.py index f005f7a5..adcc4d95 100644 --- a/torchquantum/density/test.py +++ b/torchquantum/density/test.py @@ -1,16 +1,27 @@ +import torch + from torchquantum.density import density_mat from torchquantum.density import density_func - - - if __name__ == "__main__": mat = density_func.mat_dict["hadamard"] + + Xgatemat = density_func.mat_dict["paulix"] print(mat) - D = density_mat.DensityMatrix(2) + D = density_mat.DensityMatrix(2, 2) + + rho = torch.zeros(2 ** 4,) + rho = torch.reshape(rho, [4, 4]) + rho[0][0] = 1 / 2 + rho[0][3] = 1 / 2 + rho[3][0] = 1 / 2 + rho[3][3] = 1 / 2 + rho = torch.reshape(rho, [2, 2, 2, 2]) + D.update_matrix(rho) D.print_2d(0) - newD=density_func.apply_unitary_density_bmm(D._matrix,mat,[0]) + newD = density_func.apply_unitary_density_bmm(D._matrix, Xgatemat, [1]) D.update_matrix(newD) D.print_2d(0) + From e81bb81e74bc60220c988a31118433d597917fcf Mon Sep 17 00:00:00 2001 From: Zhuoyang Ye Date: Fri, 19 Jan 2024 18:00:22 -0800 Subject: [PATCH 070/106] Add noisedevices class. --- torchquantum/device/noisedevices.py | 90 +++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 torchquantum/device/noisedevices.py diff --git a/torchquantum/device/noisedevices.py b/torchquantum/device/noisedevices.py new file mode 100644 index 00000000..e5ecc9b0 --- /dev/null +++ b/torchquantum/device/noisedevices.py @@ -0,0 +1,90 @@ +""" +MIT License + +Copyright (c) 2020-present TorchQuantum Authors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import torch +import torch.nn as nn +import numpy as np + +from torchquantum.macro import C_DTYPE +from torchquantum.functional import func_name_dict, func_name_dict_collect +from torchquantum.density import density_mat, density_func +from typing import Union + +__all__ = ["NoiseDevice"] + + +class NoiseDevice(nn.Module): + def __init__( + self, + n_wires: int, + device_name: str = "default", + bsz: int = 1, + device: Union[torch.device, str] = "cpu", + record_op: bool = False, + ): + """A quantum device that support the density matrix simulation + Args: + n_wires: number of qubits + device_name: name of the quantum device + bsz: batch size of the quantum state + device: which classical computing device to use, 'cpu' or 'cuda' + record_op: whether to record the operations on the quantum device and then + they can be used to construct a static computation graph + """ + super().__init__() + # number of qubits + # the states are represented in a multi-dimension tensor + # from left to right: qubit 0 to n + self.n_wires = n_wires + self.device_name = device_name + self.bsz = bsz + self.device = device + + _matrix = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) + _matrix[0] = 1 + 0j + _matrix = torch.reshape(_matrix, [2] * (2 * self.n_wires)) + self._dims = 2 * self.n_wires + self.register_buffer("matrix", _matrix) + + repeat_times = [bsz] + [1] * len(self.density.shape) # type: ignore + self._matrices = self.state.repeat(*repeat_times) # type: ignore + self.register_buffer("matrices", self._matrices) + + self.record_op = record_op + self.op_history = [] + + @property + def name(self): + """Return the name of the device.""" + return self.__class__.__name__ + + def __repr__(self): + return f" class: {self.name} \n device name: {self.device_name} \n number of qubits: {self.n_wires} \n batch size: {self.bsz} \n current computing device: {self.state.device} \n recording op history: {self.record_op} \n current states: {repr(self.get_states_1d().cpu().detach().numpy())}" + + +for func_name, func in func_name_dict.items(): + setattr(NoiseDevice, func_name, func) + +for func_name, func in func_name_dict_collect.items(): + setattr(NoiseDevice, func_name, func) From ac024912052c370629d789fcd888a8bced2b2af5 Mon Sep 17 00:00:00 2001 From: Zhuoyang Ye Date: Fri, 19 Jan 2024 18:11:10 -0800 Subject: [PATCH 071/106] Remove redudant code in the density matrix calculation. --- torchquantum/density/density_func.py | 2994 +------------------------- torchquantum/device/noisedevices.py | 12 +- 2 files changed, 14 insertions(+), 2992 deletions(-) diff --git a/torchquantum/density/density_func.py b/torchquantum/density/density_func.py index 842c28c9..da234437 100644 --- a/torchquantum/density/density_func.py +++ b/torchquantum/density/density_func.py @@ -34,70 +34,8 @@ from torchquantum.util import normalize_statevector __all__ = [ - "func_name_dict", - "mat_dict", "apply_unitary_density_einsum", "apply_unitary_density_bmm", - "hadamard", - "shadamard", - "paulix", - "pauliy", - "pauliz", - "i", - "s", - "t", - "sx", - "cnot", - "cz", - "cy", - "swap", - "sswap", - "cswap", - "toffoli", - "multicnot", - "multixcnot", - "rx", - "ry", - "rz", - "rxx", - "ryy", - "rzz", - "rzx", - "phaseshift", - "rot", - "multirz", - "crx", - "cry", - "crz", - "crot", - "u1", - "u2", - "u3", - "cu1", - "cu2", - "cu3", - "qubitunitary", - "qubitunitaryfast", - "qubitunitarystrict", - "single_excitation", - "h", - "sh", - "x", - "y", - "z", - "xx", - "yy", - "zz", - "zx", - "cx", - "ccnot", - "ccx", - "u", - "cu", - "p", - "cp", - "cr", - "cphase", "reset", ] @@ -280,7 +218,7 @@ def apply_unitary_density_bmm(density, mat, wires): # matrix no batch, state in batch mode bsz = permuted_dag.shape[0] expand_shape = [bsz] + list(matdag.shape) - new_density =permuted_dag.bmm( matdag.expand(expand_shape)) + new_density = permuted_dag.bmm(matdag.expand(expand_shape)) _matrix = torch.reshape(new_density[0], [2 ** n_qubit] * 2) return new_density @@ -289,7 +227,7 @@ def gate_wrapper( name, mat, method, - q_device: tq.QuantumDevice, + q_device: tq.NoiseDevice, wires, params=None, n_wires=None, @@ -373,15 +311,16 @@ def gate_wrapper( matrix = matrix.permute(0, 2, 1) else: matrix = matrix.permute(1, 0) - print("Computing") - state = q_device.states + + density = q_device.density + if method == "einsum": - q_device.states = apply_unitary_density_einsum(state, matrix, wires) + q_device.states = apply_unitary_density_einsum(density, matrix, wires) elif method == "bmm": - q_device.states = apply_unitary_density_bmm(state, matrix, wires) + q_device.states = apply_unitary_density_bmm(density, matrix, wires) -def reset(q_device: tq.QuantumDevice, wires, inverse=False) -> None: +def reset(q_device: tq.NoiseDevice, wires, inverse=False) -> None: """Reset the target qubits to the state 0. It is a non-unitary operation. Args: @@ -425,2920 +364,3 @@ def reset(q_device: tq.QuantumDevice, wires, inverse=False) -> None: # normalize the magnitude of states q_device.states = normalize_statevector(q_device.states) - - -def rx_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for rx gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - """ - Seems to be a pytorch bug. Have to explicitly cast the theta to a - complex number. If directly theta = params, then get error: - - allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag - RuntimeError: Expected isFloatingType(grad.scalar_type()) || - (input_is_complex == grad_is_complex) to be true, but got false. - (Could this error message be improved? - If so, please report an enhancement request to PyTorch.) - """ - - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(-theta / 2) - - return torch.stack( - [torch.cat([co, jsi], dim=-1), torch.cat([jsi, co], dim=-1)], dim=-2 - ).squeeze(0) - - -def ry_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for ry gate. - - Args: - params: The rotation angle. - - Returns: - The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [torch.cat([co, -si], dim=-1), torch.cat([si, co], dim=-1)], dim=-2 - ).squeeze(0) - - -def rz_matrix(params: torch.Tensor) -> torch.Tensor: - """Compute unitary matrix for rz gate. - - Args: - params: The rotation angle. - - Returns: - The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - exp = torch.exp(-0.5j * theta) - - return torch.stack( - [ - torch.cat([exp, torch.zeros(exp.shape, device=params.device)], dim=-1), - torch.cat( - [torch.zeros(exp.shape, device=params.device), torch.conj(exp)], dim=-1 - ), - ], - dim=-2, - ).squeeze(0) - - -def phaseshift_matrix(params): - """Compute the phase shift matrix. - - Args: - params (torch.Tensor): Input parameters. - - Returns: - torch.Tensor: The phase shift matrix. - - Examples: - >>> params = torch.tensor([0.5]) - >>> matrix = phaseshift_matrix(params) - >>> print(matrix) - - >>> params = torch.tensor([1.0, 2.0, 3.0]) - >>> matrix = phaseshift_matrix(params) - >>> print(matrix) - """ - phi = params.type(C_DTYPE) - exp = torch.exp(1j * phi) - - return torch.stack( - [ - torch.cat( - [ - torch.ones(exp.shape, device=params.device), - torch.zeros(exp.shape, device=params.device), - ], - dim=-1, - ), - torch.cat([torch.zeros(exp.shape, device=params.device), exp], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def rot_matrix(params): - """Compute unitary matrix for rot gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - theta = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - omega = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [ - torch.cat( - [ - torch.exp(-0.5j * (phi + omega)) * co, - -torch.exp(0.5j * (phi - omega)) * si, - ], - dim=-1, - ), - torch.cat( - [ - torch.exp(-0.5j * (phi - omega)) * si, - torch.exp(0.5j * (phi + omega)) * co, - ], - dim=-1, - ), - ], - dim=-2, - ).squeeze(0) - - -def multirz_eigvals(params, n_wires): - """Compute eigenvalue for multiqubit RZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed eigenvalues. - """ - - theta = params.type(C_DTYPE) - return torch.exp( - -1j * theta / 2 * torch.tensor(pauli_eigs(n_wires)).to(params.device) - ) - - -def multirz_matrix(params, n_wires): - """Compute unitary matrix for multiqubit RZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - # torch diagonal not available for complex number - eigvals = multirz_eigvals(params, n_wires) - dia = diag(eigvals) - return dia.squeeze(0) - - -def rxx_matrix(params): - """Compute unitary matrix for RXX gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = co[:, 0] - matrix[:, 1, 1] = co[:, 0] - matrix[:, 2, 2] = co[:, 0] - matrix[:, 3, 3] = co[:, 0] - - matrix[:, 0, 3] = -jsi[:, 0] - matrix[:, 1, 2] = -jsi[:, 0] - matrix[:, 2, 1] = -jsi[:, 0] - matrix[:, 3, 0] = -jsi[:, 0] - - return matrix.squeeze(0) - - -def ryy_matrix(params): - """Compute unitary matrix for RYY gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = co[:, 0] - matrix[:, 1, 1] = co[:, 0] - matrix[:, 2, 2] = co[:, 0] - matrix[:, 3, 3] = co[:, 0] - - matrix[:, 0, 3] = jsi[:, 0] - matrix[:, 1, 2] = -jsi[:, 0] - matrix[:, 2, 1] = -jsi[:, 0] - matrix[:, 3, 0] = jsi[:, 0] - - return matrix.squeeze(0) - - -def rzz_matrix(params): - """Compute unitary matrix for RZZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - exp = torch.exp(-0.5j * theta) - conj_exp = torch.conj(exp) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(exp.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = exp[:, 0] - matrix[:, 1, 1] = conj_exp[:, 0] - matrix[:, 2, 2] = conj_exp[:, 0] - matrix[:, 3, 3] = exp[:, 0] - - return matrix.squeeze(0) - - -def rzx_matrix(params): - """Compute unitary matrix for RZX gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - - matrix[:, 0, 0] = co[:, 0] - matrix[:, 0, 1] = -jsi[:, 0] - - matrix[:, 1, 0] = -jsi[:, 0] - matrix[:, 1, 1] = co[:, 0] - - matrix[:, 2, 2] = co[:, 0] - matrix[:, 2, 3] = jsi[:, 0] - - matrix[:, 3, 2] = jsi[:, 0] - matrix[:, 3, 3] = co[:, 0] - - return matrix.squeeze(0) - - -def crx_matrix(params): - """Compute unitary matrix for CRX gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - jsi = 1j * torch.sin(-theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - matrix[:, 2, 2] = co[:, 0] - matrix[:, 2, 3] = jsi[:, 0] - matrix[:, 3, 2] = jsi[:, 0] - matrix[:, 3, 3] = co[:, 0] - - return matrix.squeeze(0) - - -def cry_matrix(params): - """Compute unitary matrix for CRY gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(co.shape[0], 1, 1) - ) - matrix[:, 2, 2] = co[:, 0] - matrix[:, 2, 3] = -si[:, 0] - matrix[:, 3, 2] = si[:, 0] - matrix[:, 3, 3] = co[:, 0] - - return matrix.squeeze(0) - - -def crz_matrix(params): - """Compute unitary matrix for CRZ gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - exp = torch.exp(-0.5j * theta) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(exp.shape[0], 1, 1) - ) - matrix[:, 2, 2] = exp[:, 0] - matrix[:, 3, 3] = torch.conj(exp[:, 0]) - - return matrix.squeeze(0) - - -def crot_matrix(params): - """Compute unitary matrix for CRot gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - phi = params[:, 0].type(C_DTYPE) - theta = params[:, 1].type(C_DTYPE) - omega = params[:, 2].type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 2] = torch.exp(-0.5j * (phi + omega)) * co - matrix[:, 2, 3] = -torch.exp(0.5j * (phi - omega)) * si - matrix[:, 3, 2] = torch.exp(-0.5j * (phi - omega)) * si - matrix[:, 3, 3] = torch.exp(0.5j * (phi + omega)) * co - - return matrix.squeeze(0) - - -def u1_matrix(params): - """Compute unitary matrix for U1 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - phi = params.type(C_DTYPE) - exp = torch.exp(1j * phi) - - return torch.stack( - [ - torch.cat( - [ - torch.ones(exp.shape, device=params.device), - torch.zeros(exp.shape, device=params.device), - ], - dim=-1, - ), - torch.cat([torch.zeros(exp.shape, device=params.device), exp], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def cu1_matrix(params): - """Compute unitary matrix for CU1 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - phi = params.type(C_DTYPE) - exp = torch.exp(1j * phi) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 3, 3] = exp - - return matrix.squeeze(0) - - -def u2_matrix(params): - """Compute unitary matrix for U2 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - - return INV_SQRT2 * torch.stack( - [ - torch.cat( - [torch.ones(phi.shape, device=params.device), -torch.exp(1j * lam)], - dim=-1, - ), - torch.cat([torch.exp(1j * phi), torch.exp(1j * (phi + lam))], dim=-1), - ], - dim=-2, - ).squeeze(0) - - -def cu2_matrix(params): - """Compute unitary matrix for CU2 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - phi = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 3] = -torch.exp(1j * lam) - matrix[:, 3, 2] = torch.exp(1j * phi) - matrix[:, 3, 3] = torch.exp(1j * (phi + lam)) - - return matrix.squeeze(0) - - -def u3_matrix(params): - """Compute unitary matrix for U3 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - return torch.stack( - [ - torch.cat([co, -si * torch.exp(1j * lam)], dim=-1), - torch.cat( - [si * torch.exp(1j * phi), co * torch.exp(1j * (phi + lam))], dim=-1 - ), - ], - dim=-2, - ).squeeze(0) - - -def cu3_matrix(params): - """Compute unitary matrix for CU3 gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params[:, 0].unsqueeze(dim=-1).type(C_DTYPE) - phi = params[:, 1].unsqueeze(dim=-1).type(C_DTYPE) - lam = params[:, 2].unsqueeze(dim=-1).type(C_DTYPE) - - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(phi.shape[0], 1, 1) - ) - - matrix[:, 2, 2] = co - matrix[:, 2, 3] = -si * torch.exp(1j * lam) - matrix[:, 3, 2] = si * torch.exp(1j * phi) - matrix[:, 3, 3] = co * torch.exp(1j * (phi + lam)) - - return matrix.squeeze(0) - - -def qubitunitary_matrix(params): - """Compute unitary matrix for Qubitunitary gate. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - - Raises: - AssertionError: If Operator is other than square matrix - """ - - matrix = params.squeeze(0) - try: - assert matrix.shape[-1] == matrix.shape[-2] - except AssertionError as err: - logger.exception(f"Operator must be a square matrix.") - raise err - - try: - U = matrix.cpu().detach().numpy() - if matrix.dim() > 2: - # batched unitary - bsz = matrix.shape[0] - assert np.allclose( - np.matmul(U, np.transpose(U.conj(), [0, 2, 1])), - np.stack([np.identity(U.shape[-1])] * bsz), - atol=1e-5, - ) - else: - assert np.allclose( - np.matmul(U, np.transpose(U.conj(), [1, 0])), - np.identity(U.shape[0]), - atol=1e-5, - ) - except AssertionError as err: - logger.exception(f"Operator must be unitary.") - raise err - - return matrix - - -def qubitunitaryfast_matrix(params): - """Compute unitary matrix for Qubitunitary fast gate. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - return params.squeeze(0) - - -def qubitunitarystrict_matrix(params): - """Compute unitary matrix for Qubitunitary strict gate. - Strictly be the unitary. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - params.squeeze(0) - mat = params - U, Sigma, V = torch.svd(mat) - return U.matmul(V) - - -def multicnot_matrix(n_wires): - """Compute unitary matrix for Multi qubit CNOT gate. - - Args: - n_wires (int): The number of wires. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - mat = torch.eye(2 ** n_wires, dtype=C_DTYPE) - mat[-1][-1] = 0 - mat[-2][-2] = 0 - mat[-1][-2] = 1 - mat[-2][-1] = 1 - - return mat - - -def multixcnot_matrix(n_wires): - """Compute unitary matrix for Multi qubit XCNOT gate. - - Args: - params (torch.Tensor): The unitary matrix. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - # when all control qubits are zero, then the target qubit will flip - mat = torch.eye(2 ** n_wires, dtype=C_DTYPE) - mat[0][0] = 0 - mat[1][1] = 0 - mat[0][1] = 1 - mat[1][0] = 1 - - return mat - - -def single_excitation_matrix(params): - """Compute unitary matrix for single excitation gate. - - Args: - params (torch.Tensor): The rotation angle. - - Returns: - torch.Tensor: The computed unitary matrix. - """ - - theta = params.type(C_DTYPE) - co = torch.cos(theta / 2) - si = torch.sin(theta / 2) - - matrix = ( - torch.tensor( - [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1]], - dtype=C_DTYPE, - device=params.device, - ) - .unsqueeze(0) - .repeat(theta.shape[0], 1, 1) - ) - - matrix[:, 1, 1] = co - matrix[:, 1, 2] = -si - matrix[:, 2, 1] = si - matrix[:, 2, 2] = co - - return matrix.squeeze(0) - - -mat_dict = { - "hadamard": torch.tensor( - [[INV_SQRT2, INV_SQRT2], [INV_SQRT2, -INV_SQRT2]], dtype=C_DTYPE - ), - "shadamard": torch.tensor( - [ - [np.cos(np.pi / 8), -np.sin(np.pi / 8)], - [np.sin(np.pi / 8), np.cos(np.pi / 8)], - ], - dtype=C_DTYPE, - ), - "paulix": torch.tensor([[0, 1], [1, 0]], dtype=C_DTYPE), - "pauliy": torch.tensor([[0, -1j], [1j, 0]], dtype=C_DTYPE), - "pauliz": torch.tensor([[1, 0], [0, -1]], dtype=C_DTYPE), - "i": torch.tensor([[1, 0], [0, 1]], dtype=C_DTYPE), - "s": torch.tensor([[1, 0], [0, 1j]], dtype=C_DTYPE), - "t": torch.tensor([[1, 0], [0, np.exp(1j * np.pi / 4)]], dtype=C_DTYPE), - "sx": 0.5 * torch.tensor([[1 + 1j, 1 - 1j], [1 - 1j, 1 + 1j]], dtype=C_DTYPE), - "cnot": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]], dtype=C_DTYPE - ), - "cz": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]], dtype=C_DTYPE - ), - "cy": torch.tensor( - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, -1j], [0, 0, 1j, 0]], dtype=C_DTYPE - ), - "swap": torch.tensor( - [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=C_DTYPE - ), - "sswap": torch.tensor( - [ - [1, 0, 0, 0], - [0, (1 + 1j) / 2, (1 - 1j) / 2, 0], - [0, (1 - 1j) / 2, (1 + 1j) / 2, 0], - [0, 0, 0, 1], - ], - dtype=C_DTYPE, - ), - "cswap": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 1, 0], - [0, 0, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 1], - ], - dtype=C_DTYPE, - ), - "toffoli": torch.tensor( - [ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 1], - [0, 0, 0, 0, 0, 0, 1, 0], - ], - dtype=C_DTYPE, - ), - "rx": rx_matrix, - "ry": ry_matrix, - "rz": rz_matrix, - "rxx": rxx_matrix, - "ryy": ryy_matrix, - "rzz": rzz_matrix, - "rzx": rzx_matrix, - "phaseshift": phaseshift_matrix, - "rot": rot_matrix, - "multirz": multirz_matrix, - "crx": crx_matrix, - "cry": cry_matrix, - "crz": crz_matrix, - "crot": crot_matrix, - "u1": u1_matrix, - "u2": u2_matrix, - "u3": u3_matrix, - "cu1": cu1_matrix, - "cu2": cu2_matrix, - "cu3": cu3_matrix, - "qubitunitary": qubitunitary_matrix, - "qubitunitaryfast": qubitunitaryfast_matrix, - "qubitunitarystrict": qubitunitarystrict_matrix, - "multicnot": multicnot_matrix, - "multixcnot": multixcnot_matrix, - "single_excitation": single_excitation_matrix, -} - - -def hadamard( - q_device: tq.QuantumDevice, - wires: Union[List[int], int], - params: torch.Tensor = None, - n_wires: int = None, - static: bool = False, - parent_graph=None, - inverse: bool = False, - comp_method: str = "bmm", -): - """Perform the hadamard gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "hadamard" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def shadamard( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the shadamard gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "shadamard" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def paulix( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the Pauli X gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "paulix" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def pauliy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the Pauli Y gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "pauliy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def pauliz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the Pauli Z gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "pauliz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def i( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the I gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "i" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def s( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the s gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "s" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def t( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the t gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "t" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def sx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the sx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "sx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cnot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cnot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cy gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "rx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def ry( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the ry gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "ry" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "rz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rxx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rxx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "rxx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def ryy( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the ryy gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "ryy" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rzz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rzz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "rzz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rzx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rzx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "rzx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def swap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the swap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "swap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def sswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the sswap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "sswap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cswap( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cswap gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cswap" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def toffoli( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the toffoli gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "toffoli" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def phaseshift( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the phaseshift gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "phaseshift" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def rot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the rot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "rot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def multirz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the multi qubit RZ gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "multirz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def crx( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the crx gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "crx" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cry( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cry gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cry" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def crz( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the crz gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "crz" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def crot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the crot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "crot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def u1( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the u1 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "u1" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def u2( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the u2 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "u2" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def u3( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the u3 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "u3" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu1( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu1 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cu1" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu2( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu2 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cu2" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def cu3( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the cu3 gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "cu3" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qubitunitary( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the qubitunitary gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "qubitunitary" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qubitunitaryfast( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the qubitunitaryfast gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "qubitunitaryfast" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def qubitunitarystrict( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the qubitunitarystrict = gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "qubitunitarystrict" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def multicnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the multi qubit cnot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "multicnot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def multixcnot( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the multi qubit xcnot gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "multixcnot" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -def single_excitation( - q_device, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, - comp_method="bmm", -): - """Perform the single excitation gate. - - Args: - q_device (tq.QuantumDevice): The QuantumDevice. - wires (Union[List[int], int]): Which qubit(s) to apply the gate. - params (torch.Tensor, optional): Parameters (if any) of the gate. - Default to None. - n_wires (int, optional): Number of qubits the gate is applied to. - Default to None. - static (bool, optional): Whether use static mode computation. - Default to False. - parent_graph (tq.QuantumGraph, optional): Parent QuantumGraph of - current operation. Default to None. - inverse (bool, optional): Whether inverse the gate. Default to False. - comp_method (bool, optional): Use 'bmm' or 'einsum' method to perform - matrix vector multiplication. Default to 'bmm'. - - Returns: - None. - """ - - name = "single_excitation" - mat = mat_dict[name] - gate_wrapper( - name=name, - mat=mat, - method=comp_method, - q_device=q_device, - wires=wires, - params=params, - n_wires=n_wires, - static=static, - parent_graph=parent_graph, - inverse=inverse, - ) - - -h = hadamard -sh = shadamard -x = paulix -y = pauliy -z = pauliz -xx = rxx -yy = ryy -zz = rzz -zx = rzx -cx = cnot -ccnot = toffoli -ccx = toffoli -u = u3 -cu = cu3 -p = phaseshift -cp = cu1 -cr = cu1 -cphase = cu1 - -func_name_dict = { - "hadamard": hadamard, - "sh": shadamard, - "paulix": paulix, - "pauliy": pauliy, - "pauliz": pauliz, - "i": i, - "s": s, - "t": t, - "sx": sx, - "cnot": cnot, - "cz": cz, - "cy": cy, - "rx": rx, - "ry": ry, - "rz": rz, - "rxx": rxx, - "xx": xx, - "ryy": ryy, - "yy": yy, - "rzz": rzz, - "zz": zz, - "rzx": rzx, - "zx": zx, - "swap": swap, - "sswap": sswap, - "cswap": cswap, - "toffoli": toffoli, - "phaseshift": phaseshift, - "p": p, - "cp": cp, - "rot": rot, - "multirz": multirz, - "crx": crx, - "cry": cry, - "crz": crz, - "crot": crot, - "u1": u1, - "u2": u2, - "u3": u3, - "u": u, - "cu1": cu1, - "cphase": cphase, - "cr": cr, - "cu2": cu2, - "cu3": cu3, - "cu": cu, - "qubitunitary": qubitunitary, - "qubitunitaryfast": qubitunitaryfast, - "qubitunitarystrict": qubitunitarystrict, - "multicnot": multicnot, - "multixcnot": multixcnot, - "x": x, - "y": y, - "z": z, - "cx": cx, - "ccnot": ccnot, - "ccx": ccx, - "reset": reset, -} diff --git a/torchquantum/device/noisedevices.py b/torchquantum/device/noisedevices.py index e5ecc9b0..bef1fe94 100644 --- a/torchquantum/device/noisedevices.py +++ b/torchquantum/device/noisedevices.py @@ -61,15 +61,15 @@ def __init__( self.bsz = bsz self.device = device - _matrix = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) - _matrix[0] = 1 + 0j - _matrix = torch.reshape(_matrix, [2] * (2 * self.n_wires)) + _density = torch.zeros(2 ** (2 * self.n_wires), dtype=C_DTYPE) + _density[0] = 1 + 0j + _density = torch.reshape(_density, [2] * (2 * self.n_wires)) self._dims = 2 * self.n_wires - self.register_buffer("matrix", _matrix) + self.register_buffer("density", _density) repeat_times = [bsz] + [1] * len(self.density.shape) # type: ignore - self._matrices = self.state.repeat(*repeat_times) # type: ignore - self.register_buffer("matrices", self._matrices) + self._densities = self.density.repeat(*repeat_times) # type: ignore + self.register_buffer("densities", self._densities) self.record_op = record_op self.op_history = [] From 4739d75a1eb60538df099324ca7e440c639215d5 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 15 Oct 2023 19:01:29 -0400 Subject: [PATCH 072/106] running example to test functionality --- .github/workflows/example_tests.yaml | 32 +++++++++++++++++++++++++ .github/workflows/functional_tests.yaml | 3 +++ 2 files changed, 35 insertions(+) create mode 100644 .github/workflows/example_tests.yaml diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml new file mode 100644 index 00000000..d8db7db3 --- /dev/null +++ b/.github/workflows/example_tests.yaml @@ -0,0 +1,32 @@ +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python + +name: Python package + +on: + push: + pull_request: + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] + + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v3 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider + if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Test Examples + run: | + python3 examples/qubit_rotation/qubit_rotation.py diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index af549120..ed42b3e5 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -36,3 +36,6 @@ jobs: - name: Test with pytest run: | pytest -m "not skip" + - name: Test Examples + run: | + python3 examples/qubit_rotation/qubit_rotation.py From 0db9cc932d49f9db088f7c94f134ad1b20508c23 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 15 Oct 2023 19:09:43 -0400 Subject: [PATCH 073/106] fixing attempt --- .github/workflows/functional_tests.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index ed42b3e5..9b26ef72 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -36,6 +36,9 @@ jobs: - name: Test with pytest run: | pytest -m "not skip" + - name: Install TorchQuantum + run: | + pip install --editable . - name: Test Examples run: | python3 examples/qubit_rotation/qubit_rotation.py From ac4853e99c648b056903982683d68f938e948be3 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 12:45:34 -0500 Subject: [PATCH 074/106] added tests and slight modification to rotation --- .github/workflows/example_tests.yaml | 15 ++++++++++++++- examples/qubit_rotation/qubit_rotation.py | 14 +++++++++++--- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index d8db7db3..6cf931f4 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -29,4 +29,17 @@ jobs: if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Test Examples run: | - python3 examples/qubit_rotation/qubit_rotation.py + python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 + python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 + python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 + python3 examples/train_state_prep/train_state_prep.py --epochs 1 + python3 examples/superdense_coding/superdense_coding_torchquantum.py + python3 examples/regression/run_regression.py --epochs 1 + python3 examples/param_shift_onchip_training/param_shift.py + python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 + python3 examples/hadamard_grad/circ.py + python3 examples/encoder_examples/encoder_8x2ry.py + python3 examples/converter_tq_qiskit/convert.py + python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 + python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 + python3 examples/PauliSumOp/pauli_sum_op.py diff --git a/examples/qubit_rotation/qubit_rotation.py b/examples/qubit_rotation/qubit_rotation.py index be2dfc82..bae1e803 100644 --- a/examples/qubit_rotation/qubit_rotation.py +++ b/examples/qubit_rotation/qubit_rotation.py @@ -6,6 +6,7 @@ import torchquantum as tq import torch from torchquantum.measurement import expval_joint_analytical +import argparse class OptimizationModel(torch.nn.Module): @@ -42,7 +43,7 @@ def train(model, device, optimizer): # main function to run the optimization -def main(): +def main(n_epochs): seed = 0 torch.manual_seed(seed) @@ -50,7 +51,6 @@ def main(): device = torch.device("cuda" if use_cuda else "cpu") model = OptimizationModel() - n_epochs = 200 optimizer = torch.optim.SGD(model.parameters(), lr=0.1) for epoch in range(1, n_epochs + 1): @@ -65,4 +65,12 @@ def main(): if __name__ == "__main__": - main() + parser = argparse.ArgumentParser( + prog="Qubit Rotation", + description="Specify Parameters for Qubit Rotation Optimization Example", + ) + parser.add_argument( + "--epochs", type=int, default=200, help="number of training epochs" + ) + args = parser.parse_args() + main(args.epochs) From ae4f37cccad9ade2c469b20954510279d7a7ca6a Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 15:57:53 -0500 Subject: [PATCH 075/106] [minor] fix path to h2.txt file for vqe --- examples/vqe/new_simple_vqe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/vqe/new_simple_vqe.py b/examples/vqe/new_simple_vqe.py index b5a83953..31cab355 100644 --- a/examples/vqe/new_simple_vqe.py +++ b/examples/vqe/new_simple_vqe.py @@ -30,7 +30,7 @@ from torchquantum.plugin import qiskit2tq_op_history if __name__ == "__main__": - hamil = Hamiltonian.from_file("./examples/simple_vqe/h2.txt") + hamil = Hamiltonian.from_file("./examples/vqe/h2.txt") ops = [ {'name': 'u3', 'wires': 0, 'trainable': True}, From 2ee23f6272204c0fbeaf1628596158db05b864d1 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:07:10 -0500 Subject: [PATCH 076/106] [minor] updated to fully handle not having qiskit --- .github/workflows/example_tests.yaml | 1 + examples/regression/new_run_regression.py | 5 ++--- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index 6cf931f4..e5f7425c 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -43,3 +43,4 @@ jobs: python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 python3 examples/PauliSumOp/pauli_sum_op.py + python3 examples/regression/new_run_regression.py --epochs 1 diff --git a/examples/regression/new_run_regression.py b/examples/regression/new_run_regression.py index fdeb5cd4..30fc3aa7 100644 --- a/examples/regression/new_run_regression.py +++ b/examples/regression/new_run_regression.py @@ -305,12 +305,11 @@ def main(): model.set_qiskit_processor(processor_simulation) valid_test(dataflow, q_device, "test", model, device, qiskit=True) + # final valid + valid_test(dataflow, q_device, "valid", model, device, True) except: pass - # final valid - valid_test(dataflow, q_device, "valid", model, device, True) - if __name__ == "__main__": main() From ec92f93e598f51f185cc57efb32224533d65e6c7 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:28:15 -0500 Subject: [PATCH 077/106] [minor] added a missing layer --- .github/workflows/example_tests.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index e5f7425c..580e7f14 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -44,3 +44,4 @@ jobs: python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 python3 examples/PauliSumOp/pauli_sum_op.py python3 examples/regression/new_run_regression.py --epochs 1 + python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 From 21fbe08452962f9c8d5603ff7b66469cd0063994 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:34:35 -0500 Subject: [PATCH 078/106] [minor] fixed grover example dependency --- .github/workflows/example_tests.yaml | 1 + examples/grover/grover_example_sudoku.py | 4 ++-- torchquantum/algorithm/__init__.py | 1 + 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index 580e7f14..9ee0ea2e 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -45,3 +45,4 @@ jobs: python3 examples/PauliSumOp/pauli_sum_op.py python3 examples/regression/new_run_regression.py --epochs 1 python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 + python3 examples/grover/grover_example_sudoku.py diff --git a/examples/grover/grover_example_sudoku.py b/examples/grover/grover_example_sudoku.py index 25761594..4969eea2 100644 --- a/examples/grover/grover_example_sudoku.py +++ b/examples/grover/grover_example_sudoku.py @@ -28,7 +28,7 @@ """ import torchquantum as tq -from torchquantum.algorithms import Grover +from torchquantum.algorithm import Grover # To simplify the process, we can compile this set of comparisons into a list of clauses for convenience. @@ -90,4 +90,4 @@ def XOR(input0, input1, output): print("b = ", key[1]) print("c = ", key[2]) print("d = ", key[3]) - print("") \ No newline at end of file + print("") diff --git a/torchquantum/algorithm/__init__.py b/torchquantum/algorithm/__init__.py index 623d71b7..7dfb672a 100644 --- a/torchquantum/algorithm/__init__.py +++ b/torchquantum/algorithm/__init__.py @@ -25,3 +25,4 @@ from .vqe import * from .hamiltonian import * from .qft import * +from .grover import * From 4d7417ceb87bea15d4a60f88b0508a9b900224b5 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:44:51 -0500 Subject: [PATCH 079/106] [minor] adding imports for pulse --- examples/optimal_control/optimal_control.py | 2 +- examples/optimal_control/optimal_control_gaussian.py | 2 +- examples/optimal_control/optimal_control_multi_qubit.py | 6 +++--- torchquantum/__init__.py | 1 + torchquantum/pulse/__init__.py | 1 + 5 files changed, 7 insertions(+), 5 deletions(-) diff --git a/examples/optimal_control/optimal_control.py b/examples/optimal_control/optimal_control.py index 438e135b..89601153 100644 --- a/examples/optimal_control/optimal_control.py +++ b/examples/optimal_control/optimal_control.py @@ -41,7 +41,7 @@ dtype=torch.complex64, ) - pulse = tq.QuantumPulseDirect(n_steps=4, hamil=[[0, 1], [1, 0]]) + pulse = tq.pulse.QuantumPulseDirect(n_steps=4, hamil=[[0, 1], [1, 0]]) optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) diff --git a/examples/optimal_control/optimal_control_gaussian.py b/examples/optimal_control/optimal_control_gaussian.py index 861cc92a..559e6127 100644 --- a/examples/optimal_control/optimal_control_gaussian.py +++ b/examples/optimal_control/optimal_control_gaussian.py @@ -41,7 +41,7 @@ dtype=torch.complex64, ) - pulse = tq.QuantumPulseGaussian(hamil=[[0, 1], [1, 0]]) + pulse = tq.pulse.QuantumPulseGaussian(hamil=[[0, 1], [1, 0]]) optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) diff --git a/examples/optimal_control/optimal_control_multi_qubit.py b/examples/optimal_control/optimal_control_multi_qubit.py index 023d4f3c..148b526c 100644 --- a/examples/optimal_control/optimal_control_multi_qubit.py +++ b/examples/optimal_control/optimal_control_multi_qubit.py @@ -43,9 +43,9 @@ dtype=torch.complex64, ) - pulse_q0 = tq.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) - pulse_q1 = tq.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) - pulse_q01 = tq.QuantumPulseDirect( + pulse_q0 = tq.pulse.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) + pulse_q1 = tq.pulse.QuantumPulseDirect(n_steps=10, hamil=[[0, 1], [1, 0]]) + pulse_q01 = tq.pulse.QuantumPulseDirect( n_steps=10, hamil=[ [1, 0, 0, 0], diff --git a/torchquantum/__init__.py b/torchquantum/__init__.py index c8aed9ed..b1529623 100644 --- a/torchquantum/__init__.py +++ b/torchquantum/__init__.py @@ -38,6 +38,7 @@ from .noise_model import * from .algorithm import * from .dataset import * +from .pulse import * # here we check whether the Qiskit parameterization bug is fixed, if not, a # warning message will be printed diff --git a/torchquantum/pulse/__init__.py b/torchquantum/pulse/__init__.py index 5a4539de..d281a73f 100644 --- a/torchquantum/pulse/__init__.py +++ b/torchquantum/pulse/__init__.py @@ -25,4 +25,5 @@ from .utils import * from .sesolve import sesolve from .mesolve import mesolve +from .pulses import * # from .smesolve import smesolve From 7d72ff31109e474a429cfc72fe0f5be6da7c8e41 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 16:47:19 -0500 Subject: [PATCH 080/106] [minor] fixed typo in save_load --- examples/save_load_example/save_load.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/save_load_example/save_load.py b/examples/save_load_example/save_load.py index 1022c3aa..c5a6c57a 100644 --- a/examples/save_load_example/save_load.py +++ b/examples/save_load_example/save_load.py @@ -143,7 +143,7 @@ def save_load3(): # print(model.q_layer.rx0._parameters) traced_cell = torch.jit.trace(model, (x)) - torch.jit.save(traced_cell, "model_trace.pth") + torch.jit.save(traced_cell, "model_trace.pt") loaded_trace = torch.jit.load("model_trace.pt") y2 = loaded_trace(x) From 49c13a6390b50259ad60367887c11d18ea570c5f Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 24 Nov 2023 17:15:05 -0500 Subject: [PATCH 081/106] [minor] added test + fixed layer import --- .github/workflows/example_tests.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml index 9ee0ea2e..8d0f1df6 100644 --- a/.github/workflows/example_tests.yaml +++ b/.github/workflows/example_tests.yaml @@ -46,3 +46,4 @@ jobs: python3 examples/regression/new_run_regression.py --epochs 1 python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 python3 examples/grover/grover_example_sudoku.py + python3 examples/param_shift_onchip_training/param_shift.py From 9d6fae453292deb2ca01258e6d74492f96f7d7b2 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 1 Dec 2023 21:04:31 -0500 Subject: [PATCH 082/106] moved the test locations --- .github/workflows/example_tests.yaml | 49 ------------------------- .github/workflows/functional_tests.yaml | 19 +++++++++- 2 files changed, 18 insertions(+), 50 deletions(-) delete mode 100644 .github/workflows/example_tests.yaml diff --git a/.github/workflows/example_tests.yaml b/.github/workflows/example_tests.yaml deleted file mode 100644 index 8d0f1df6..00000000 --- a/.github/workflows/example_tests.yaml +++ /dev/null @@ -1,49 +0,0 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - -name: Python package - -on: - push: - pull_request: - -jobs: - build: - - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] - - steps: - - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 - with: - python-version: ${{ matrix.python-version }} - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - - name: Test Examples - run: | - python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 - python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 - python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 - python3 examples/train_state_prep/train_state_prep.py --epochs 1 - python3 examples/superdense_coding/superdense_coding_torchquantum.py - python3 examples/regression/run_regression.py --epochs 1 - python3 examples/param_shift_onchip_training/param_shift.py - python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 - python3 examples/hadamard_grad/circ.py - python3 examples/encoder_examples/encoder_8x2ry.py - python3 examples/converter_tq_qiskit/convert.py - python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 - python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 - python3 examples/PauliSumOp/pauli_sum_op.py - python3 examples/regression/new_run_regression.py --epochs 1 - python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 - python3 examples/grover/grover_example_sudoku.py - python3 examples/param_shift_onchip_training/param_shift.py diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 9b26ef72..7b9dfb50 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -41,4 +41,21 @@ jobs: pip install --editable . - name: Test Examples run: | - python3 examples/qubit_rotation/qubit_rotation.py + python3 examples/qubit_rotation/qubit_rotation.py --epochs 1 + python3 examples/vqe/vqe.py --epochs 1 --steps_per_epoch 1 + python3 examples/train_unitary_prep/train_unitary_prep.py --epochs 1 + python3 examples/train_state_prep/train_state_prep.py --epochs 1 + python3 examples/superdense_coding/superdense_coding_torchquantum.py + python3 examples/regression/run_regression.py --epochs 1 + python3 examples/param_shift_onchip_training/param_shift.py + python3 examples/mnist/mnist_2qubit_4class.py --epochs 1 + python3 examples/hadamard_grad/circ.py + python3 examples/encoder_examples/encoder_8x2ry.py + python3 examples/converter_tq_qiskit/convert.py + python3 examples/amplitude_encoding_mnist/mnist_new.py --epochs 1 + python3 examples/amplitude_encoding_mnist/mnist_example.py --epochs 1 + python3 examples/PauliSumOp/pauli_sum_op.py + python3 examples/regression/new_run_regression.py --epochs 1 + python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 + python3 examples/grover/grover_example_sudoku.py + python3 examples/param_shift_onchip_training/param_shift.py From d135c4bf1a87408de56c630324b00b81daa3b7cf Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 1 Dec 2023 21:38:49 -0500 Subject: [PATCH 083/106] [minor] removed unnecessary tests and added tests for python 3.12 --- .github/workflows/functional_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 7b9dfb50..334d32cf 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -14,7 +14,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"] + python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v3 From 26f4040b54e067056f93fc1be5f5cb2a28d12d74 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 24 Dec 2023 15:43:01 -0600 Subject: [PATCH 084/106] [minor] added parameters for quanvolution and qlstm --- .github/workflows/functional_tests.yaml | 2 + examples/quantum_lstm/qlstm.py | 22 ++++++--- examples/quanvolution/quanvolution.py | 59 +++++++++++++++---------- 3 files changed, 54 insertions(+), 29 deletions(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 334d32cf..f48522cc 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -59,3 +59,5 @@ jobs: python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 python3 examples/grover/grover_example_sudoku.py python3 examples/param_shift_onchip_training/param_shift.py + python3 examples/python3 quanvolution.py --epochs 1 + python3 examples/quantum_lstm/qlstm.py --epochs 1 diff --git a/examples/quantum_lstm/qlstm.py b/examples/quantum_lstm/qlstm.py index b2f3e32f..82c9258b 100644 --- a/examples/quantum_lstm/qlstm.py +++ b/examples/quantum_lstm/qlstm.py @@ -31,6 +31,7 @@ import torch.nn as nn import torchquantum as tq import torchquantum.functional as tqf +import argparse class QLSTM(nn.Module): @@ -358,6 +359,19 @@ def plot_history(history_classical, history_quantum): plt.show() def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument("--display", action="store_true", help="display results with matplotlib") + parser.add_argument( + "--epochs", type=int, default=300, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + tag_to_ix = {"DET": 0, "NN": 1, "V": 2} # Assign each tag with a unique index ix_to_tag = {i:k for k,i in tag_to_ix.items()} @@ -380,7 +394,7 @@ def main(): embedding_dim = 8 hidden_dim = 6 - n_epochs = 300 + n_epochs = args.epochs model_classical = LSTMTagger(embedding_dim, hidden_dim, @@ -404,10 +418,8 @@ def main(): print_result(model_quantum, training_data, word_to_ix, ix_to_tag) - plot_history(history_classical, history_quantum) + if args.display: + plot_history(history_classical, history_quantum) if __name__ == "__main__": - import pdb - pdb.set_trace() - main() diff --git a/examples/quanvolution/quanvolution.py b/examples/quanvolution/quanvolution.py index ada4561b..28ee592b 100644 --- a/examples/quanvolution/quanvolution.py +++ b/examples/quanvolution/quanvolution.py @@ -30,6 +30,7 @@ import torch.optim as optim import numpy as np import random +import argparse from torchquantum.dataset import MNIST from torch.optim.lr_scheduler import CosineAnnealingLR @@ -150,8 +151,17 @@ def valid_test(dataflow, split, model, device, qiskit=False): def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--epochs", type=int, default=15, help="number of training epochs" + ) + parser.add_argument( + "--qiskit-simulation", action="store_true", help="run the program on a real quantum computer" + ) + args = parser.parse_args() + train_model_without_qf = True - n_epochs = 15 + n_epochs = args.epochs random.seed(42) np.random.seed(42) @@ -220,29 +230,30 @@ def main(): scheduler.step() - # run on real QC - try: - from qiskit import IBMQ - from torchquantum.plugin import QiskitProcessor - - # firstly perform simulate - print(f"\nTest with Qiskit Simulator") - processor_simulation = QiskitProcessor(use_real_qc=False) - model.qf.set_qiskit_processor(processor_simulation) - valid_test(dataflow, "test", model, device, qiskit=True) - # then try to run on REAL QC - backend_name = "ibmq_quito" - print(f"\nTest on Real Quantum Computer {backend_name}") - processor_real_qc = QiskitProcessor(use_real_qc=True, backend_name=backend_name) - model.qf.set_qiskit_processor(processor_real_qc) - valid_test(dataflow, "test", model, device, qiskit=True) - except ImportError: - print( - "Please install qiskit, create an IBM Q Experience Account and " - "save the account token according to the instruction at " - "'https://github.com/Qiskit/qiskit-ibmq-provider', " - "then try again." - ) + if args.qiskit_simulation: + # run on real QC + try: + from qiskit import IBMQ + from torchquantum.plugin import QiskitProcessor + + # firstly perform simulate + print(f"\nTest with Qiskit Simulator") + processor_simulation = QiskitProcessor(use_real_qc=False) + model.qf.set_qiskit_processor(processor_simulation) + valid_test(dataflow, "test", model, device, qiskit=True) + # then try to run on REAL QC + backend_name = "ibmq_quito" + print(f"\nTest on Real Quantum Computer {backend_name}") + processor_real_qc = QiskitProcessor(use_real_qc=True, backend_name=backend_name) + model.qf.set_qiskit_processor(processor_real_qc) + valid_test(dataflow, "test", model, device, qiskit=True) + except ImportError: + print( + "Please install qiskit, create an IBM Q Experience Account and " + "save the account token according to the instruction at " + "'https://github.com/Qiskit/qiskit-ibmq-provider', " + "then try again." + ) if __name__ == "__main__": From 66a7fc01e163e87369856cfe92ef29555d0f9a3a Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 24 Dec 2023 15:57:30 -0600 Subject: [PATCH 085/106] [minor] update typo --- .github/workflows/functional_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index f48522cc..10a5d030 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -59,5 +59,5 @@ jobs: python3 examples/quanvolution/quanvolution_trainable_quantum_layer.py --epochs 1 python3 examples/grover/grover_example_sudoku.py python3 examples/param_shift_onchip_training/param_shift.py - python3 examples/python3 quanvolution.py --epochs 1 + python3 examples/quanvolution/quanvolution.py --epochs 1 python3 examples/quantum_lstm/qlstm.py --epochs 1 From 16b7d0677944da7a3052d76f444183cbb74472c3 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 24 Dec 2023 22:50:33 -0600 Subject: [PATCH 086/106] [minor] add tests for optimal_control, qaoa, mnist --- .github/workflows/functional_tests.yaml | 6 ++ examples/mnist/mnist.py | 66 ++++++++++--------- examples/optimal_control/optimal_control.py | 17 ++++- .../optimal_control_gaussian.py | 17 ++++- .../optimal_control_multi_qubit.py | 17 ++++- examples/qaoa/max_cut_backprop.py | 9 ++- 6 files changed, 90 insertions(+), 42 deletions(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index 10a5d030..f234d0b0 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -61,3 +61,9 @@ jobs: python3 examples/param_shift_onchip_training/param_shift.py python3 examples/quanvolution/quanvolution.py --epochs 1 python3 examples/quantum_lstm/qlstm.py --epochs 1 + python3 examples/qaoa/max_cut_backprop.py --steps 1 + python3 examples/optimal_control/optimal_control.py --epochs 1 + python3 examples/optimal_control/optimal_control_gaussian.py --epochs 1 + python3 examples/optimal_control/optimal_control_multi_qubit.py --epochs 1 + python3 examples/save_load_example/save_load.py + python3 examples/mnist/mnist.py --epochs 1 diff --git a/examples/mnist/mnist.py b/examples/mnist/mnist.py index 23e5eafe..d8b32e25 100644 --- a/examples/mnist/mnist.py +++ b/examples/mnist/mnist.py @@ -179,6 +179,7 @@ def main(): "--static", action="store_true", help="compute with " "static mode" ) parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument("--qiskit-simulation", action="store_true", help="run on a real quantum computer") parser.add_argument( "--wires-per-block", type=int, default=2, help="wires per block int static mode" ) @@ -243,38 +244,39 @@ def main(): # test valid_test(dataflow, "test", model, device, qiskit=False) - # run on Qiskit simulator and real Quantum Computers - try: - from qiskit import IBMQ - from torchquantum.plugin import QiskitProcessor - - # firstly perform simulate - print(f"\nTest with Qiskit Simulator") - processor_simulation = QiskitProcessor(use_real_qc=False) - model.set_qiskit_processor(processor_simulation) - valid_test(dataflow, "test", model, device, qiskit=True) - - # then try to run on REAL QC - backend_name = "ibmq_lima" - print(f"\nTest on Real Quantum Computer {backend_name}") - # Please specify your own hub group and project if you have the - # IBMQ premium plan to access more machines. - processor_real_qc = QiskitProcessor( - use_real_qc=True, - backend_name=backend_name, - hub="ibm-q", - group="open", - project="main", - ) - model.set_qiskit_processor(processor_real_qc) - valid_test(dataflow, "test", model, device, qiskit=True) - except ImportError: - print( - "Please install qiskit, create an IBM Q Experience Account and " - "save the account token according to the instruction at " - "'https://github.com/Qiskit/qiskit-ibmq-provider', " - "then try again." - ) + if args.qiskit_simulation: + # run on Qiskit simulator and real Quantum Computers + try: + from qiskit import IBMQ + from torchquantum.plugin import QiskitProcessor + + # firstly perform simulate + print(f"\nTest with Qiskit Simulator") + processor_simulation = QiskitProcessor(use_real_qc=False) + model.set_qiskit_processor(processor_simulation) + valid_test(dataflow, "test", model, device, qiskit=True) + + # then try to run on REAL QC + backend_name = "ibmq_lima" + print(f"\nTest on Real Quantum Computer {backend_name}") + # Please specify your own hub group and project if you have the + # IBMQ premium plan to access more machines. + processor_real_qc = QiskitProcessor( + use_real_qc=True, + backend_name=backend_name, + hub="ibm-q", + group="open", + project="main", + ) + model.set_qiskit_processor(processor_real_qc) + valid_test(dataflow, "test", model, device, qiskit=True) + except ImportError: + print( + "Please install qiskit, create an IBM Q Experience Account and " + "save the account token according to the instruction at " + "'https://github.com/Qiskit/qiskit-ibmq-provider', " + "then try again." + ) if __name__ == "__main__": diff --git a/examples/optimal_control/optimal_control.py b/examples/optimal_control/optimal_control.py index 89601153..2bff28c4 100644 --- a/examples/optimal_control/optimal_control.py +++ b/examples/optimal_control/optimal_control.py @@ -26,11 +26,22 @@ import torch.optim as optim import torchquantum as tq -import pdb +import argparse import numpy as np if __name__ == "__main__": - pdb.set_trace() + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument( + "--epochs", type=int, default=1000, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + # target_unitary = torch.tensor([[0, 1], [1, 0]], dtype=torch.complex64) theta = 0.6 target_unitary = torch.tensor( @@ -45,7 +56,7 @@ optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) - for k in range(1000): + for k in range(args.epochs): # loss = (abs(pulse.get_unitary() - target_unitary)**2).sum() loss = ( 1 diff --git a/examples/optimal_control/optimal_control_gaussian.py b/examples/optimal_control/optimal_control_gaussian.py index 559e6127..51192173 100644 --- a/examples/optimal_control/optimal_control_gaussian.py +++ b/examples/optimal_control/optimal_control_gaussian.py @@ -26,11 +26,22 @@ import torch.optim as optim import torchquantum as tq -import pdb +import argparse import numpy as np if __name__ == "__main__": - pdb.set_trace() + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument( + "--epochs", type=int, default=1000, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + # target_unitary = torch.tensor([[0, 1], [1, 0]], dtype=torch.complex64) theta = 1.1 target_unitary = torch.tensor( @@ -45,7 +56,7 @@ optimizer = optim.Adam(params=pulse.parameters(), lr=5e-3) - for k in range(1000): + for k in range(args.epochs): # loss = (abs(pulse.get_unitary() - target_unitary)**2).sum() loss = ( 1 diff --git a/examples/optimal_control/optimal_control_multi_qubit.py b/examples/optimal_control/optimal_control_multi_qubit.py index 148b526c..5658f269 100644 --- a/examples/optimal_control/optimal_control_multi_qubit.py +++ b/examples/optimal_control/optimal_control_multi_qubit.py @@ -26,11 +26,22 @@ import torch.optim as optim import torchquantum as tq -import pdb +import argparse import numpy as np if __name__ == "__main__": - pdb.set_trace() + parser = argparse.ArgumentParser() + parser.add_argument("--pdb", action="store_true", help="debug with pdb") + parser.add_argument( + "--epochs", type=int, default=1000, help="number of training epochs" + ) + + args = parser.parse_args() + + if args.pdb: + import pdb + pdb.set_trace() + # target_unitary = torch.tensor([[0, 1], [1, 0]], dtype=torch.complex64) theta = 0.6 target_unitary = torch.tensor( @@ -62,7 +73,7 @@ lr=5e-3, ) - for k in range(1000): + for k in range(args.epochs): u_0 = pulse_q0.get_unitary() u_1 = pulse_q1.get_unitary() u_01 = pulse_q01.get_unitary() diff --git a/examples/qaoa/max_cut_backprop.py b/examples/qaoa/max_cut_backprop.py index 803d16c9..2f9b2210 100644 --- a/examples/qaoa/max_cut_backprop.py +++ b/examples/qaoa/max_cut_backprop.py @@ -27,6 +27,7 @@ import random import numpy as np +import argparse from torchquantum.functional import mat_dict @@ -172,6 +173,12 @@ def backprop_optimize(model, n_steps=100, lr=0.1): def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--steps", type=int, default=300, help="number of steps" + ) + args = parser.parse_args() + # create a input_graph input_graph = [(0, 1), (0, 3), (1, 2), (2, 3)] n_wires = 4 @@ -184,7 +191,7 @@ def main(): # print("The circuit is", circ.draw(output="mpl")) # circ.draw(output="mpl") # use backprop - backprop_optimize(model, n_steps=300, lr=0.01) + backprop_optimize(model, n_steps=args.steps, lr=0.01) # use parameter shift rule # param_shift_optimize(model, n_steps=500, step_size=100000) From 43c2a2c7b07775f543f288581fa118474af30365 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 19 Jan 2024 21:19:37 -0500 Subject: [PATCH 087/106] [minor] rm layers.py to resolve merge conflict --- torchquantum/layer/layers.py | 1857 ---------------------------------- 1 file changed, 1857 deletions(-) delete mode 100644 torchquantum/layer/layers.py diff --git a/torchquantum/layer/layers.py b/torchquantum/layer/layers.py deleted file mode 100644 index a645158d..00000000 --- a/torchquantum/layer/layers.py +++ /dev/null @@ -1,1857 +0,0 @@ -""" -MIT License - -Copyright (c) 2020-present TorchQuantum Authors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -""" - -import torch -import torch.nn as nn -import torchquantum as tq -import torchquantum.functional as tqf -import numpy as np - - -from typing import Iterable -from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES -from torchpack.utils.logging import logger - -__all__ = [ - "QuantumModuleFromOps", - "TrainableOpAll", - "ClassicalInOpAll", - "FixedOpAll", - "TwoQAll", - "RandomLayer", - "RandomLayerAllTypes", - "Op1QAllLayer", - "RandomOp1All", - "Op2QAllLayer", - "Op2QButterflyLayer", - "Op2QDenseLayer", - "layer_name_dict", - "CXLayer", - "CXCXCXLayer", - "SWAPSWAPLayer", - "RXYZCXLayer0", - "U3CU3Layer0", - "QFTLayer", - "SethLayer0", - "EntangleLinear", - "EntanglePairwise", - "EntangleFull", - "EntangleCircular", - "EntanglementLayer", - "SethLayer0", -] - - -class QuantumModuleFromOps(tq.QuantumModule): - """Initializes a QuantumModuleFromOps instance. - - Args: - ops (List[tq.Operation]): List of quantum operations. - - """ - - def __init__(self, ops): - super().__init__() - self.ops = tq.QuantumModuleList(ops) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - """Performs the forward pass of the quantum module. - - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - - Returns: - None - - """ - self.q_device = q_device - for op in self.ops: - op(q_device) - - -class TrainableOpAll(tq.QuantumModule): - """Rotation rx on all qubits - The rotation angle is a parameter of each rotation gate - One potential optimization is to compute the unitary of all gates - together. - """ - - def __init__(self, n_gate: int, op: tq.Operation): - super().__init__() - self.n_gate = n_gate - self.gate_all = nn.ModuleList() - for k in range(self.n_gate): - self.gate_all.append(op(has_params=True, trainable=True)) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - # rx on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of rx gates ({self.n_gate}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_gate): - self.gate_all[k](q_device, wires=k) - - -class ClassicalInOpAll(tq.QuantumModule): - """ - Quantum module that applies the same quantum operation to all wires of a quantum device, - where the parameters of the operation are obtained from a classical input. - - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. - - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. - - """ - - def __init__(self, n_gate: int, op: tq.Operator): - super().__init__() - self.n_gate = n_gate - self.gate_all = nn.ModuleList() - for k in range(self.n_gate): - self.gate_all.append(op()) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice, x): - """ - Performs the forward pass of the classical input quantum operation module. - - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - x (torch.Tensor): Classical input of shape (batch_size, n_gate). - - Returns: - None - - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. - - """ - # rx on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of rx gates ({self.n_gate}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_gate): - self.gate_all[k](q_device, wires=k, params=x[:, k]) - - -class FixedOpAll(tq.QuantumModule): - """ - Quantum module that applies the same fixed quantum operation to all wires of a quantum device. - - Args: - n_gate (int): Number of gates. - op (tq.Operator): Quantum operation to be applied. - - Attributes: - n_gate (int): Number of gates. - gate_all (nn.ModuleList): List of quantum operations. - - """ - - def __init__(self, n_gate: int, op: tq.Operator): - super().__init__() - self.n_gate = n_gate - self.gate_all = nn.ModuleList() - for k in range(self.n_gate): - self.gate_all.append(op()) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - """ - Performs the forward pass of the fixed quantum operation module. - - Args: - q_device (tq.QuantumDevice): Quantum device to apply the operations on. - - Returns: - None - - Raises: - AssertionError: If the number of gates is different from the number of wires in the device. - - """ - # rx on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of rx gates ({self.n_gate}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_gate): - self.gate_all[k](q_device, wires=k) - - -class TwoQAll(tq.QuantumModule): - """ - Quantum module that applies a two-qubit quantum operation to adjacent pairs of wires in a quantum device. - - Args: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation to be applied. - - Attributes: - n_gate (int): Number of adjacent pairs of wires. - op (tq.Operator): Two-qubit quantum operation. - - """ - - def __init__(self, n_gate: int, op: tq.Operator): - super().__init__() - self.n_gate = n_gate - self.op = op() - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - for k in range(self.n_gate - 1): - self.op(q_device, wires=[k, k + 1]) - self.op(q_device, wires=[self.n_gate - 1, 0]) - - -class RandomOp1All(tq.QuantumModule): - def __init__( - self, n_wires: int, op_types=(tq.RX, tq.RY, tq.RZ), op_ratios=None, seed=None - ): - """Layer adding a random gate to all wires - - Params: - n_wires (int): number of wires/gates in integer format - op_types (Iterable): single-wire gates to select from in iterable format - op_ratios (Iterable): probabilities to select each gate option in iterable format - seed (int): random seed in integer format - """ - super().__init__() - self.n_wires = n_wires - self.op_types = op_types - self.op_ratios = op_ratios - self.seed = seed - self.gate_all = nn.ModuleList() - if seed is not None: - np.random.seed(seed) - self.build_random_layer() - - def build_random_layer(self): - for k in range(self.n_wires): - op = np.random.choice(self.op_types, p=self.op_ratios) - self.gate_all.append(op()) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice, x): - # op on all wires, assert the number of gate is the same as the number - # of wires in the device. - assert self.n_gate == q_device.n_wires, ( - f"Number of gates ({self.n_wires}) is different from number " - f"of wires ({q_device.n_wires})!" - ) - - for k in range(self.n_wires): - self.gate_all[k](q_device, wires=k, params=x[:, k]) - - -class RandomLayer(tq.QuantumModule): - """ - Quantum module that represents a random layer of quantum operations applied to specified wires. - - Args: - wires (int or Iterable[int]): Indices of the wires the operations are applied to. - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - op_ratios (list or float): Ratios determining the relative frequencies of different operation types. - op_types (tuple or tq.Operator): Types of random operations to be included in the layer. - seed (int): Seed for random number generation. - qiskit_compatible (bool): Flag indicating whether the layer should be compatible with Qiskit. - - Attributes: - n_ops (int): Number of random operations in the layer. - n_params (int): Number of parameters for each random operation. - wires (list): Indices of the wires the operations are applied to. - n_wires (int): Number of wires. - op_types (list): Types of random operations included in the layer. - op_ratios (numpy.array): Ratios determining the relative frequencies of different operation types. - seed (int): Seed for random number generation. - op_list (tq.QuantumModuleList): List of random operations in the layer. - - """ - - def __init__( - self, - wires, - n_ops=None, - n_params=None, - op_ratios=None, - op_types=(tq.RX, tq.RY, tq.RZ, tq.CNOT), - seed=None, - qiskit_compatible=False, - ): - super().__init__() - self.n_ops = n_ops - self.n_params = n_params - assert n_params is not None or n_ops is not None - self.wires = wires if isinstance(wires, Iterable) else [wires] - self.n_wires = len(wires) - - op_types = op_types if isinstance(op_types, Iterable) else [op_types] - if op_ratios is None: - op_ratios = [1] * len(op_types) - else: - op_ratios = op_ratios if isinstance(op_ratios, Iterable) else [op_ratios] - op_types_valid = [] - op_ratios_valid = [] - - if qiskit_compatible: - for op_type, op_ratio in zip(op_types, op_ratios): - if op_type().name.lower() in QISKIT_INCOMPATIBLE_FUNC_NAMES: - logger.warning( - f"Remove {op_type} from op_types to make " - f"the layer qiskit-compatible." - ) - else: - op_types_valid.append(op_type) - op_ratios_valid.append(op_ratio) - else: - op_types_valid = op_types - op_ratios_valid = op_ratios - - self.op_types = op_types_valid - self.op_ratios = np.array(op_ratios_valid) / sum(op_ratios_valid) - - self.seed = seed - self.op_list = tq.QuantumModuleList() - if seed is not None: - np.random.seed(seed) - self.build_random_layer() - - def rebuild_random_layer_from_op_list(self, n_ops_in, wires_in, op_list_in): - """ - Rebuilds a random layer from the given operation list. - This method is used for loading a random layer from a checkpoint. - - Args: - n_ops_in (int): Number of operations in the layer. - wires_in (list): Indices of the wires the operations are applied to. - op_list_in (list): List of operations in the layer. - - """ - - self.n_ops = n_ops_in - self.wires = wires_in - self.op_list = tq.QuantumModuleList() - for op_in in op_list_in: - op = tq.op_name_dict[op_in.name.lower()]( - has_params=op_in.has_params, - trainable=op_in.trainable, - wires=op_in.wires, - n_wires=op_in.n_wires, - ) - self.op_list.append(op) - - def build_random_layer(self): - op_cnt = 0 - param_cnt = 0 - while True: - op = np.random.choice(self.op_types, p=self.op_ratios) - n_op_wires = op.num_wires - if n_op_wires > self.n_wires: - continue - if n_op_wires == -1: - is_AnyWire = True - n_op_wires = self.n_wires - else: - is_AnyWire = False - - op_wires = list( - np.random.choice(self.wires, size=n_op_wires, replace=False) - ) - if is_AnyWire: - if op().name in ["MultiRZ"]: - operation = op( - has_params=True, - trainable=True, - n_wires=n_op_wires, - wires=op_wires, - ) - else: - operation = op(n_wires=n_op_wires, wires=op_wires) - elif op().name in tq.operator.parameterized_ops: - operation = op(has_params=True, trainable=True, wires=op_wires) - else: - operation = op(wires=op_wires) - self.op_list.append(operation) - op_cnt += 1 - param_cnt += op.num_params - - if self.n_ops is not None and op_cnt == self.n_ops: - break - elif self.n_ops is None and self.n_params is not None: - if param_cnt == self.n_params: - break - elif param_cnt > self.n_params: - """ - the last operation has too many params and exceed the - constraint, so need to remove it and sample another - """ - op_cnt -= 1 - param_cnt -= op.num_params - del self.op_list[-1] - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - for op in self.op_list: - op(q_device) - - -class RandomLayerAllTypes(RandomLayer): - """ - Random layer with a wide range of quantum gate types. - - This class extends the `RandomLayer` class to include a variety of quantum gate types as options for the random layer. - - Args: - wires (int or list): Indices of the wires the operations are applied to. - n_ops (int): Number of operations in the layer. - n_params (int): Number of parameters for each operation. - op_ratios (list): Ratios for selecting different types of operations. - op_types (tuple): Types of operations to include in the layer. - seed (int): Seed for the random number generator. - qiskit_compatible (bool): Flag indicating whether the layer should be Qiskit-compatible. - - """ - - def __init__( - self, - wires, - n_ops=None, - n_params=None, - op_ratios=None, - op_types=( - tq.Hadamard, - tq.SHadamard, - tq.PauliX, - tq.PauliY, - tq.PauliZ, - tq.S, - tq.T, - tq.SX, - tq.CNOT, - tq.CZ, - tq.CY, - tq.RX, - tq.RY, - tq.RZ, - tq.RZZ, - tq.SWAP, - tq.CSWAP, - tq.Toffoli, - tq.PhaseShift, - tq.Rot, - tq.MultiRZ, - tq.CRX, - tq.CRY, - tq.CRZ, - tq.CRot, - tq.U1, - tq.U2, - tq.U3, - tq.MultiCNOT, - tq.MultiXCNOT, - ), - seed=None, - qiskit_compatible=False, - ): - super().__init__( - wires=wires, - n_ops=n_ops, - n_params=n_params, - op_ratios=op_ratios, - op_types=op_types, - seed=seed, - qiskit_compatible=qiskit_compatible, - ) - - -class SimpleQLayer(tq.QuantumModule): - """ - Simple quantum layer consisting of three parameterized gates applied to specific wires. - - This class represents a simple quantum layer with three parameterized gates: RX, RY, and RZ. The gates are applied to specific wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - self.gate1 = tq.RX(has_params=True, trainable=True) - self.gate2 = tq.RY(has_params=True, trainable=True) - self.gate3 = tq.RZ(has_params=True, trainable=True) - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.x(q_dev, wires=0, static=self.static_mode, parent_graph=self.graph) - self.gate1(q_dev, wires=1) - self.gate2(q_dev, wires=1) - self.gate3(q_dev, wires=1) - tqf.x(q_dev, wires=2, static=self.static_mode, parent_graph=self.graph) - - -class CXLayer(tq.QuantumModule): - """ - Quantum layer with a controlled-X (CX) gate applied to two specified wires. - - This class represents a quantum layer with a controlled-X (CX) gate applied to two specified wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - - -class CXCXCXLayer(tq.QuantumModule): - """ - Quantum layer with a sequence of CX gates applied to three specified wires. - - This class represents a quantum layer with a sequence of CX gates applied to three specified wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.cnot(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - tqf.cnot(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) - tqf.cnot(q_dev, wires=[2, 0], static=self.static_mode, parent_graph=self.graph) - - -class SWAPSWAPLayer(tq.QuantumModule): - """ - Quantum layer with a sequence of SWAP gates applied to two specified pairs of wires. - - This class represents a quantum layer with a sequence of SWAP gates applied to two specified pairs of wires in the quantum device. - - Args: - n_wires (int): Number of wires in the quantum device. - - """ - - def __init__(self, n_wires): - super().__init__() - self.n_wires = n_wires - - @tq.static_support - def forward(self, q_dev): - self.q_device = q_dev - tqf.swap(q_dev, wires=[0, 1], static=self.static_mode, parent_graph=self.graph) - tqf.swap(q_dev, wires=[1, 2], static=self.static_mode, parent_graph=self.graph) - - -class Op1QAllLayer(tq.QuantumModule): - """ - Quantum layer applying the same single-qubit operation to all wires. - - This class represents a quantum layer that applies the same single-qubit operation to all wires in the quantum device. - - Args: - op (tq.Operator): Single-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - - """ - - def __init__(self, op, n_wires: int, has_params=False, trainable=False): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - for k in range(n_wires): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device): - for k in range(self.n_wires): - self.ops_all[k](q_device, wires=k) - - -class Op2QAllLayer(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the - specified jump. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - """pattern: - circular = False - jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] - jump = 2: [0, 2], [1, 3], [2, 4], [3, 5] - jump = 3: [0, 3], [1, 4], [2, 5] - jump = 4: [0, 4], [1, 5] - jump = 5: [0, 5] - - circular = True - jump = 1: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] - jump = 2: [0, 2], [1, 3], [2, 4], [3, 5], [4, 0], [5, 1] - jump = 3: [0, 3], [1, 4], [2, 5], [3, 0], [4, 1], [5, 2] - jump = 4: [0, 4], [1, 5], [2, 0], [3, 1], [4, 2], [5, 3] - jump = 5: [0, 5], [1, 0], [2, 1], [3, 2], [4, 3], [5, 4] - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - jump=1, - circular=False, - ): - super().__init__() - self.n_wires = n_wires - self.jump = jump - self.circular = circular - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - if circular: - n_ops = n_wires - else: - n_ops = n_wires - jump - for k in range(n_ops): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device): - for k in range(len(self.ops_all)): - wires = [k, (k + self.jump) % self.n_wires] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - - -class Op2QFit32Layer(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires, fitting to 32 operations. - - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires in the quantum device. The pairs of wires can be determined in a circular or non-circular pattern based on the specified jump. The layer is designed to fit to 32 operations by repeating the same operation pattern multiple times. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - jump=1, - circular=False, - ): - super().__init__() - self.n_wires = n_wires - self.jump = jump - self.circular = circular - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - # if circular: - # n_ops = n_wires - # else: - # n_ops = n_wires - jump - n_ops = 32 - for k in range(n_ops): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - @tq.static_support - def forward(self, q_device): - for k in range(len(self.ops_all)): - wires = [k % self.n_wires, (k + self.jump) % self.n_wires] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - - -class Op2QButterflyLayer(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation in a butterfly pattern. - - This class represents a quantum layer that applies the same two-qubit operation in a butterfly pattern. The butterfly pattern connects the first and last wire, the second and second-to-last wire, and so on, until the center wire(s) in the case of an odd number of wires. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - - """ - - """pattern: [0, 5], [1, 4], [2, 3]""" - - def __init__( - self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False - ): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - for k in range(n_wires // 2): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - def forward(self, q_device): - for k in range(len(self.ops_all)): - wires = [k, self.n_wires - 1 - k] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - - -class EntangleFull(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation in a dense pattern. - - This class represents a quantum layer that applies the same two-qubit operation in a dense pattern. The dense pattern connects every pair of wires, ensuring that each wire is connected to every other wire exactly once. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - - """ - - """pattern: - [0, 1], [0, 2], [0, 3], [0, 4], [0, 5] - [1, 2], [1, 3], [1, 4], [1, 5] - [2, 3], [2, 4], [2, 5] - [3, 4], [3, 5] - [4, 5] - """ - - def __init__( - self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False - ): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - for k in range(self.n_wires * (self.n_wires - 1) // 2): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - def forward(self, q_device): - k = 0 - for i in range(self.n_wires - 1): - for j in range(i + 1, self.n_wires): - wires = [i, j] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - k += 1 - - -# Adding an alias to the previous name -Op2QDenseLayer = EntangleFull - - -class LayerTemplate0(tq.QuantumModule): - """ - A template for a custom quantum layer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. (Optional) - n_layers_per_block (int): The number of layers per block. (Optional) - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Abstract method to build the layers of the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def __init__(self, arch: dict = None): - super().__init__() - self.n_wires = arch["n_wires"] - self.arch = arch - - self.n_blocks = arch.get("n_blocks", None) - self.n_layers_per_block = arch.get("n_layers_per_block", None) - - self.layers_all = self.build_layers() - - def build_layers(self): - raise NotImplementedError - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - self.q_device = q_device - for k in range(len(self.layers_all)): - self.layers_all[k](q_device) - - -class U3CU3Layer0(LayerTemplate0): - """ - Layer template with U3 and CU3 blocks. - - This layer template consists of U3 and CU3 blocks repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the U3 and CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.U3, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class CU3Layer0(LayerTemplate0): - """ - Layer template with CU3 blocks. - - This layer template consists of CU3 blocks repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the CU3 layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=False, - ) - ) - return layers_all - - -class CXRZSXLayer0(LayerTemplate0): - """ - Layer template with CXRZSX blocks. - - This layer template consists of CXRZSX blocks, which include RZ, CNOT, and SX gates, repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the CXRZSX layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=False) - ) - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.SX, n_wires=self.n_wires, has_params=False, trainable=False - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class SethLayer0(LayerTemplate0): - """ - Layer template with Seth blocks. - - This layer template consists of Seth blocks, which include RZZ and RY gates, repeated for the specified number of blocks. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class SethLayer1(LayerTemplate0): - """ - Layer template with extended Seth blocks. - - This layer template consists of extended Seth blocks, which include RZZ and RY gates repeated twice for each block. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the extended Seth layers for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class SethLayer2(LayerTemplate0): - """ - Layer template with Seth blocks using Op2QFit32Layer. - - This layer template consists of Seth blocks using the Op2QFit32Layer, which includes RZZ gates and supports 32 wires. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Seth layers with Op2QFit32Layer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QFit32Layer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class RZZLayer0(LayerTemplate0): - """ - Layer template with RZZ blocks. - - This layer template consists of RZZ blocks using the Op2QAllLayer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RZZ layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZZ, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class BarrenLayer0(LayerTemplate0): - """ - Layer template with Barren blocks. - - This layer template consists of Barren blocks using the Op1QAllLayer and Op2QAllLayer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Barren layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - layers_all.append( - Op1QAllLayer( - op=tq.SHadamard, - n_wires=self.n_wires, - ) - ) - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op2QAllLayer(op=tq.CZ, n_wires=self.n_wires, jump=1)) - return layers_all - - -class FarhiLayer0(LayerTemplate0): - """ - Layer template with Farhi blocks. - - This layer template consists of Farhi blocks using the Op2QAllLayer. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Farhi layers with Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op2QAllLayer( - op=tq.RZX, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.RXX, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - return layers_all - - -class MaxwellLayer0(LayerTemplate0): - """ - Layer template with Maxwell blocks. - - This layer template consists of Maxwell blocks using the Op1QAllLayer and Op2QAllLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the Maxwell layers with Op1QAllLayer and Op2QAllLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op1QAllLayer(op=tq.S, n_wires=self.n_wires)) - layers_all.append( - Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) - ) - - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op1QAllLayer(op=tq.T, n_wires=self.n_wires)) - layers_all.append( - Op2QAllLayer(op=tq.SWAP, n_wires=self.n_wires, jump=1, circular=True) - ) - - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(Op1QAllLayer(op=tq.Hadamard, n_wires=self.n_wires)) - layers_all.append( - Op2QAllLayer(op=tq.SSWAP, n_wires=self.n_wires, jump=1, circular=True) - ) - - layers_all.append( - Op1QAllLayer( - op=tq.U1, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer( - op=tq.CU3, - n_wires=self.n_wires, - has_params=True, - trainable=True, - jump=1, - circular=True, - ) - ) - - return layers_all - - -class RYRYCXLayer0(LayerTemplate0): - """ - Layer template with RYRYCX blocks. - - This layer template consists of RYRYCX blocks using the Op1QAllLayer and CXLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYCX layers with Op1QAllLayer and CXLayer for the template. - forward: Applies the quantum layer to the given quantum device. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(CXLayer(n_wires=self.n_wires)) - return layers_all - - -class RYRYRYCXCXCXLayer0(LayerTemplate0): - """ - Layer template with RYRYRYCXCXCX blocks. - - This layer template consists of RYRYRYCXCXCX blocks using the RYRYCXCXLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with RYRYCXCXLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(CXCXCXLayer(n_wires=self.n_wires)) - return layers_all - - -class RYRYRYLayer0(LayerTemplate0): - """ - Layer template with RYRYRYCXCXCX blocks. - - This layer template consists of RYRYRYCXCXCX blocks using the Op1QAllLayer and CXCXCXLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYCXCXCX layers with Op1QAllLayer and CXCXCXLayer for the template. - - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - return layers_all - - -class RYRYRYSWAPSWAPLayer0(LayerTemplate0): - """ - Layer template with RYRYRYSWAPSWAP blocks. - - This layer template consists of RYRYRYSWAPSWAP blocks using the Op1QAllLayer and SWAPSWAPLayer modules. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RYRYRYSWAPSWAP layers with Op1QAllLayer and SWAPSWAPLayer for the template. - - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) - return layers_all - - -class SWAPSWAPLayer0(LayerTemplate0): - """ - Layer template with SWAPSWAP blocks. - - This layer template consists of SWAPSWAP blocks using the SWAPSWAPLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the SWAPSWAP layers with SWAPSWAPLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append(SWAPSWAPLayer(n_wires=self.n_wires)) - return layers_all - - -class RXYZCXLayer0(LayerTemplate0): - """ - Layer template with RXYZCX blocks. - - This layer template consists of RXYZCX blocks using the RXYZCXLayer module. - - Args: - arch (dict, optional): The architecture configuration for the layer. Defaults to None. - - Attributes: - n_wires (int): The number of wires in the layer. - arch (dict): The architecture configuration for the layer. - n_blocks (int): The number of blocks in the layer. - layers_all (tq.QuantumModuleList): The list of layers in the template. - - Methods: - build_layers: Builds the RXYZCX layers with RXYZCXLayer for the template. - - """ - - def build_layers(self): - layers_all = tq.QuantumModuleList() - for k in range(self.arch["n_blocks"]): - layers_all.append( - Op1QAllLayer( - op=tq.RX, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RY, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op1QAllLayer( - op=tq.RZ, n_wires=self.n_wires, has_params=True, trainable=True - ) - ) - layers_all.append( - Op2QAllLayer(op=tq.CNOT, n_wires=self.n_wires, jump=1, circular=True) - ) - return layers_all - - -class QFTLayer(tq.QuantumModule): - def __init__( - self, - n_wires: int = None, - wires: Iterable = None, - do_swaps: bool = True, - inverse: bool = False, - ): - """ - Constructs a Quantum Fourier Transform (QFT) layer - - Args: - n_wires (int): Number of wires for the QFT as an integer - wires (Iterable): Wires to perform the QFT as an Iterable - do_swaps (bool): Whether or not to add the final swaps in a boolean format - inverse (bool): Whether to create an inverse QFT layer in a boolean format - """ - super().__init__() - - assert n_wires is not None or wires is not None - - if n_wires is None: - self.n_wires = len(wires) - - if wires is None: - wires = range(n_wires) - - self.n_wires = n_wires - self.wires = wires - self.do_swaps = do_swaps - - if inverse: - self.gates_all = self.build_inverse_circuit() - else: - self.gates_all = self.build_circuit() - - def build_circuit(self): - """Construct a QFT circuit.""" - - operation_list = [] - - # add the H and CU1 gates - for top_wire in range(self.n_wires): - operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) - for wire in range(top_wire + 1, self.n_wires): - lam = torch.pi / (2 ** (wire - top_wire)) - operation_list.append( - { - "name": "cu1", - "params": lam, - "wires": [self.wires[wire], self.wires[top_wire]], - } - ) - - # add swaps if specified - if self.do_swaps: - for wire in range(self.n_wires // 2): - operation_list.append( - { - "name": "swap", - "wires": [ - self.wires[wire], - self.wires[self.n_wires - wire - 1], - ], - } - ) - - return tq.QuantumModule.from_op_history(operation_list) - - def build_inverse_circuit(self): - """Construct the inverse of a QFT circuit.""" - - operation_list = [] - - # add swaps if specified - if self.do_swaps: - for wire in range(self.n_wires // 2): - operation_list.append( - { - "name": "swap", - "wires": [ - self.wires[wire], - self.wires[self.n_wires - wire - 1], - ], - } - ) - - # add the CU1 and H gates - for top_wire in range(self.n_wires)[::-1]: - for wire in range(top_wire + 1, self.n_wires)[::-1]: - lam = -torch.pi / (2 ** (wire - top_wire)) - operation_list.append( - { - "name": "cu1", - "params": lam, - "wires": [self.wires[wire], self.wires[top_wire]], - } - ) - operation_list.append({"name": "hadamard", "wires": self.wires[top_wire]}) - - return tq.QuantumModule.from_op_history(operation_list) - - @tq.static_support - def forward(self, q_device: tq.QuantumDevice): - self.gates_all(q_device) - - -class EntangleLinear(Op2QAllLayer): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - """ - - """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5] - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - ): - super().__init__( - op=op, - n_wires=n_wires, - has_params=has_params, - trainable=trainable, - wire_reverse=wire_reverse, - jump=1, - circular=False, - ) - - -class EntangleCircular(Op2QAllLayer): - """ - Quantum layer applying the same two-qubit operation to all pairs of adjacent wires in a circular manner. - This class represents a quantum layer that applies the same two-qubit operation to all pairs of adjacent wires - in the quantum device with a wrap-around - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - """pattern: [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0] - """ - - def __init__( - self, - op, - n_wires: int, - has_params=False, - trainable=False, - wire_reverse=False, - ): - super().__init__( - op=op, - n_wires=n_wires, - has_params=has_params, - trainable=trainable, - wire_reverse=wire_reverse, - jump=1, - circular=True, - ) - - -class EntanglePairwise(tq.QuantumModule): - """ - Quantum layer applying the same two-qubit operation in a pair-wise pattern - - This class represents a quantum layer that applies the same two-qubit operation in a pairwise pattern. The pairwise pattern first entangles all qubits i with i+1 for even i then all qubits i with i+1 for odd i. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - - """ - - """pattern: - [0, 1], [2, 3], [4, 5] - [1, 2], [3, 4] - """ - - def __init__( - self, op, n_wires: int, has_params=False, trainable=False, wire_reverse=False - ): - super().__init__() - self.n_wires = n_wires - self.op = op - self.ops_all = tq.QuantumModuleList() - - # reverse the wires, for example from [1, 2] to [2, 1] - self.wire_reverse = wire_reverse - - for k in range(self.n_wires - 1): - self.ops_all.append(op(has_params=has_params, trainable=trainable)) - - def forward(self, q_device): - k = 0 - - # entangle qubit i with i+1 for all even values of i - for i in range(self.n_wires - 1): - if i % 2 == 0: - wires = [i, i + 1] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - k += 1 - - # entangle qubit i with i+1 for all odd values of i - for i in range(1, self.n_wires - 1): - if i % 2 == 1: - wires = [i, i + 1] - if self.wire_reverse: - wires.reverse() - self.ops_all[k](q_device, wires=wires) - k += 1 - - -class EntanglementLayer(tq.QuantumModule): - """ - Quantum layer applying a specified two-qubit entanglement type to all qubits. The entanglement types include full, linear, pairwise, and circular. - - Args: - op (tq.Operator): Two-qubit operation to be applied. - n_wires (int): Number of wires in the quantum device. - entanglement (str): Type of entanglement from ["full", "linear", "pairwise", "circular"] - has_params (bool, optional): Flag indicating if the operation has parameters. Defaults to False. - trainable (bool, optional): Flag indicating if the operation is trainable. Defaults to False. - wire_reverse (bool, optional): Flag indicating if the order of wires in each pair should be reversed. Defaults to False. - jump (int, optional): Number of positions to jump between adjacent pairs of wires. Defaults to 1. - circular (bool, optional): Flag indicating if the pattern should be circular. Defaults to False. - - """ - - def __init__( - self, - op, - n_wires: int, - entanglement: str, - has_params=False, - trainable=False, - wire_reverse=False, - ): - super().__init__() - - entanglement_to_class = { - "full": EntangleFull, - "linear": EntangleLinear, - "pairwise": EntanglePairwise, - "circular": EntangleCircular, - } - - self.entanglement_class = entanglement_to_class.get(entanglement, None) - - assert ( - self.entanglement_class is not None - ), f"invalid entanglement type {entanglement}" - - self.entanglement_class.__init__( - op=op, - n_wires=n_wires, - has_params=has_params, - trainable=trainable, - wire_reverse=wire_reverse, - ) - - @tq.static_support - def forward(self, q_device): - self.entanglement_class.forward(q_device) - - -layer_name_dict = { - "u3cu3_0": U3CU3Layer0, - "cu3_0": CU3Layer0, - "cxrzsx_0": CXRZSXLayer0, - "seth_0": SethLayer0, - "seth_1": SethLayer1, - "seth_2": SethLayer2, - "rzz_0": RZZLayer0, - "barren_0": BarrenLayer0, - "farhi_0": FarhiLayer0, - "maxwell_0": MaxwellLayer0, - "ryrycx": RYRYCXLayer0, - "ryryrycxcxcx": RYRYRYCXCXCXLayer0, - "ryryry": RYRYRYLayer0, - "swapswap": SWAPSWAPLayer0, - "ryryryswapswap": RYRYRYSWAPSWAPLayer0, - "rxyzcx_0": RXYZCXLayer0, -} From 35f1a0e626abf79cc1d53bb9bd0d20c297da6955 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 19 Jan 2024 21:31:33 -0500 Subject: [PATCH 088/106] [minor] bug fix for seth layer --- torchquantum/layer/layers/seth_layer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torchquantum/layer/layers/seth_layer.py b/torchquantum/layer/layers/seth_layer.py index c80d095e..82865172 100644 --- a/torchquantum/layer/layers/seth_layer.py +++ b/torchquantum/layer/layers/seth_layer.py @@ -32,8 +32,8 @@ from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES from torchpack.utils.logging import logger -from .layers import LayerTemplate0 - +from .layers import LayerTemplate0, Op1QAllLayer +from ..entanglement.op2_layer import Op2QAllLayer class SethLayer0(LayerTemplate0): """ From ffaaefa6bfcfccd9dbd6e991acf3fc196f00a852 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 19 Jan 2024 21:41:55 -0500 Subject: [PATCH 089/106] [minor] bugfix for sx --- torchquantum/functional/sx.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/torchquantum/functional/sx.py b/torchquantum/functional/sx.py index 7f991b4a..d35075a3 100644 --- a/torchquantum/functional/sx.py +++ b/torchquantum/functional/sx.py @@ -82,7 +82,7 @@ def sx( """ name = "sx" - mat = mat_dict[name] + mat = _sx_mat_dict[name] gate_wrapper( name=name, mat=mat, @@ -129,7 +129,7 @@ def sxdg( """ name = "sxdg" - mat = mat_dict[name] + mat = _sx_mat_dict[name] gate_wrapper( name=name, mat=mat, @@ -176,7 +176,7 @@ def csx( """ name = "csx" - mat = mat_dict[name] + mat = _sx_mat_dict[name] gate_wrapper( name=name, mat=mat, @@ -220,7 +220,7 @@ def c3sx( None. """ name = "c3sx" - mat = mat_dict[name] + mat = _sx_mat_dict[name] gate_wrapper( name=name, mat=mat, From d95c0ed68910eb425667076a4f4262cd28141baf Mon Sep 17 00:00:00 2001 From: Zhuoyang Ye Date: Fri, 19 Jan 2024 18:48:15 -0800 Subject: [PATCH 090/106] Implement noisedevice. --- torchquantum/density/density_func.py | 10 ++++- torchquantum/device/__init__.py | 3 +- torchquantum/device/noisedevices.py | 16 ++++++++ torchquantum/measurement/measurements.py | 48 ++++++++++++------------ 4 files changed, 52 insertions(+), 25 deletions(-) diff --git a/torchquantum/density/density_func.py b/torchquantum/density/density_func.py index da234437..0e4c4812 100644 --- a/torchquantum/density/density_func.py +++ b/torchquantum/density/density_func.py @@ -22,7 +22,6 @@ SOFTWARE. """ -import functools import torch import numpy as np import torchquantum as tq @@ -32,6 +31,15 @@ from ..util.utils import pauli_eigs, diag from torchpack.utils.logging import logger from torchquantum.util import normalize_statevector +from ..functional import (hadamard,shadamard,paulix,pauliy,pauliz,i,s,t,sx,cnot, + cz,cy,swap,sswap,cswap,toffoli,multicnot,multixcnot,rx,ry,rz,rxx,ryy,rzz,rzx, + phaseshift,rot,multirz,crx,cry,crz,crot,u1,u2,u3, cu,cu1, cu2, cu3, qubitunitary, + qubitunitaryfast,qubitunitarystrict,singleexcitation,h,sh,x,y,z,xx,yy,zz,zx,cx,ccnot, ccx, + u,cu, p,cp,cr,cphase,ecr,echoedcrossresonance,qft,sdg,iswap,cs, csdg,csx,chadamard,ccz, + dcx,xxminyy,xxplusyy,c3x,tdg,sxdg,ch,r,c4x,rccx,rc3x,globalphase,c3sx) + + + __all__ = [ "apply_unitary_density_einsum", diff --git a/torchquantum/device/__init__.py b/torchquantum/device/__init__.py index 1fd5a939..33e17770 100644 --- a/torchquantum/device/__init__.py +++ b/torchquantum/device/__init__.py @@ -22,4 +22,5 @@ SOFTWARE. """ -from .devices import * \ No newline at end of file +from .devices import * +from .noisedevices import * \ No newline at end of file diff --git a/torchquantum/device/noisedevices.py b/torchquantum/device/noisedevices.py index bef1fe94..54c85831 100644 --- a/torchquantum/device/noisedevices.py +++ b/torchquantum/device/noisedevices.py @@ -83,6 +83,22 @@ def __repr__(self): return f" class: {self.name} \n device name: {self.device_name} \n number of qubits: {self.n_wires} \n batch size: {self.bsz} \n current computing device: {self.state.device} \n recording op history: {self.record_op} \n current states: {repr(self.get_states_1d().cpu().detach().numpy())}" + ''' + Get the probability of measuring each state to a one dimension + tensor + ''' + def get_probs_1d(self): + """Return the states in a 1d tensor.""" + bsz = self.densities.shape[0] + densities2d=torch.reshape(self.densities, [bsz, 2**self.n_wires,2**self.n_wires]) + return torch.diagonal(densities2d, offset=0, dim1=1, dim2=2) + + def get_prob_1d(self): + """Return the state in a 1d tensor.""" + density2d=torch.reshape(self.density, [2**self.n_wires,2**self.n_wires]) + return torch.diagonal(density2d, offset=0, dim1=0, dim2=1) + + for func_name, func in func_name_dict.items(): setattr(NoiseDevice, func_name, func) diff --git a/torchquantum/measurement/measurements.py b/torchquantum/measurement/measurements.py index 2220e563..c3c2daad 100644 --- a/torchquantum/measurement/measurements.py +++ b/torchquantum/measurement/measurements.py @@ -31,7 +31,7 @@ def gen_bitstrings(n_wires): - return ["{:0{}b}".format(k, n_wires) for k in range(2**n_wires)] + return ["{:0{}b}".format(k, n_wires) for k in range(2 ** n_wires)] def measure(qdev, n_shots=1024, draw_id=None): @@ -43,8 +43,13 @@ def measure(qdev, n_shots=1024, draw_id=None): distribution of bitstrings """ bitstring_candidates = gen_bitstrings(qdev.n_wires) - - state_mag = qdev.get_states_1d().abs().detach().cpu().numpy() + if isinstance(qdev, tq.QuantumDevice): + state_mag = qdev.get_states_1d().abs().detach().cpu().numpy() + elif isinstance(qdev, tq.NoiseDevice): + ''' + Measure the density matrix in the computational basis + ''' + state_mag = qdev.get_probs_1d().abs().detach().cpu().numpy() distri_all = [] for state_mag_one in state_mag: @@ -69,7 +74,6 @@ def measure(qdev, n_shots=1024, draw_id=None): return distri_all - def find_observable_groups(observables): # the group is not unique # ["XXII", "IIZZ", "ZZII"] can be grouped as ["XXZZ", "ZZII"] or ["ZZZZ", "XXZZ"] @@ -90,7 +94,7 @@ def find_observable_groups(observables): continue else: break - else: # for this group, the observable is matched or I be replaced, so no need to try other groups + else: # for this group, the observable is matched or I be replaced, so no need to try other groups matched = True break if matched: @@ -107,9 +111,9 @@ def find_observable_groups(observables): def expval_joint_sampling_grouping( - qdev: tq.QuantumDevice, - observables: List[str], - n_shots_per_group=1024, + qdev: tq.QuantumDevice, + observables: List[str], + n_shots_per_group=1024, ): assert len(observables) == len(set(observables)), "each observable should be unique" # key is the group, values is the list of sub-observables @@ -152,7 +156,7 @@ def expval_joint_sampling_grouping( n_eigen_one += n_count else: n_eigen_minus_one += n_count - + expval = n_eigen_one / n_shots_per_group + (-1) * n_eigen_minus_one / n_shots_per_group expval_all.append(expval) @@ -162,9 +166,9 @@ def expval_joint_sampling_grouping( def expval_joint_sampling( - qdev: tq.QuantumDevice, - observable: str, - n_shots=1024, + qdev: tq.QuantumDevice, + observable: str, + n_shots=1024, ): """ Compute the expectation value of a joint observable from sampling @@ -203,7 +207,7 @@ def expval_joint_sampling( for wire in range(n_wires): for rotation in pauli_dict[observable[wire]]().diagonalizing_gates(): rotation(qdev_clone, wires=wire) - + mask = np.ones(len(observable), dtype=bool) mask[np.array([*observable]) == "I"] = False @@ -218,7 +222,7 @@ def expval_joint_sampling( n_eigen_one += n_count else: n_eigen_minus_one += n_count - + expval = n_eigen_one / n_shots + (-1) * n_eigen_minus_one / n_shots expval_all.append(expval) @@ -226,8 +230,8 @@ def expval_joint_sampling( def expval_joint_analytical( - qdev: tq.QuantumDevice, - observable: str, + qdev: tq.QuantumDevice, + observable: str, ): """ Compute the expectation value of a joint observable in analytical way, assuming the @@ -276,11 +280,10 @@ def expval_joint_analytical( def expval( - qdev: tq.QuantumDevice, - wires: Union[int, List[int]], - observables: Union[op.Observable, List[op.Observable]], + qdev: tq.QuantumDevice, + wires: Union[int, List[int]], + observables: Union[op.Observable, List[op.Observable]], ): - all_dims = np.arange(qdev.states.dim()) if isinstance(wires, int): wires = [wires] @@ -455,8 +458,9 @@ def forward(self, qdev: tq.QuantumDevice): if __name__ == '__main__': import pdb + pdb.set_trace() - qdev = tq.QuantumDevice(n_wires=2, bsz=5, device="cpu", record_op=True) # use device='cuda' for GPU + qdev = tq.QuantumDevice(n_wires=2, bsz=5, device="cpu", record_op=True) # use device='cuda' for GPU qdev.h(wires=0) qdev.cnot(wires=[0, 1]) tqf.h(qdev, wires=1) @@ -471,5 +475,3 @@ def forward(self, qdev: tq.QuantumDevice): expval = expval_joint_sampling(qdev, 'II', 100000) expval_ana = expval_joint_analytical(qdev, 'II') print(expval, expval_ana) - - From a9c13daef8db013216b7ea27d28ca2e19c21049d Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Fri, 19 Jan 2024 21:50:49 -0500 Subject: [PATCH 091/106] [minor] u3 layer bugfix --- torchquantum/layer/layers/u3_layer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torchquantum/layer/layers/u3_layer.py b/torchquantum/layer/layers/u3_layer.py index b46d8b45..f0339ed4 100644 --- a/torchquantum/layer/layers/u3_layer.py +++ b/torchquantum/layer/layers/u3_layer.py @@ -32,8 +32,8 @@ from torchquantum.plugin.qiskit import QISKIT_INCOMPATIBLE_FUNC_NAMES from torchpack.utils.logging import logger -from .layers import LayerTemplate0 - +from .layers import LayerTemplate0, Op1QAllLayer +from ..entanglement.op2_layer import Op2QAllLayer class U3CU3Layer0(LayerTemplate0): """ From 3ac389f36c583a5515c4072eb0bf44d39be0b808 Mon Sep 17 00:00:00 2001 From: Zhuoyang Ye Date: Fri, 19 Jan 2024 19:31:00 -0800 Subject: [PATCH 092/106] Add an example of running circuit on density device. --- examples/density/dexample.py | 0 torchquantum/density/density_func.py | 5 +- torchquantum/device/noisedevices.py | 5 +- torchquantum/functional/gate_wrapper.py | 225 ++++++++++++++++++++++-- 4 files changed, 212 insertions(+), 23 deletions(-) create mode 100644 examples/density/dexample.py diff --git a/examples/density/dexample.py b/examples/density/dexample.py new file mode 100644 index 00000000..e69de29b diff --git a/torchquantum/density/density_func.py b/torchquantum/density/density_func.py index 0e4c4812..fb15bf3d 100644 --- a/torchquantum/density/density_func.py +++ b/torchquantum/density/density_func.py @@ -25,7 +25,7 @@ import torch import numpy as np import torchquantum as tq - +import functools from typing import Callable, Union, Optional, List, Dict from ..macro import C_DTYPE, ABC, ABC_ARRAY, INV_SQRT2 from ..util.utils import pauli_eigs, diag @@ -227,10 +227,9 @@ def apply_unitary_density_bmm(density, mat, wires): bsz = permuted_dag.shape[0] expand_shape = [bsz] + list(matdag.shape) new_density = permuted_dag.bmm(matdag.expand(expand_shape)) - _matrix = torch.reshape(new_density[0], [2 ** n_qubit] * 2) + new_density = new_density.view(original_shape).permute(permute_back_dag) return new_density - def gate_wrapper( name, mat, diff --git a/torchquantum/device/noisedevices.py b/torchquantum/device/noisedevices.py index 54c85831..3da88eff 100644 --- a/torchquantum/device/noisedevices.py +++ b/torchquantum/device/noisedevices.py @@ -28,7 +28,6 @@ from torchquantum.macro import C_DTYPE from torchquantum.functional import func_name_dict, func_name_dict_collect -from torchquantum.density import density_mat, density_func from typing import Union __all__ = ["NoiseDevice"] @@ -38,7 +37,7 @@ class NoiseDevice(nn.Module): def __init__( self, n_wires: int, - device_name: str = "default", + device_name: str = "noisedevice", bsz: int = 1, device: Union[torch.device, str] = "cpu", record_op: bool = False, @@ -80,7 +79,7 @@ def name(self): return self.__class__.__name__ def __repr__(self): - return f" class: {self.name} \n device name: {self.device_name} \n number of qubits: {self.n_wires} \n batch size: {self.bsz} \n current computing device: {self.state.device} \n recording op history: {self.record_op} \n current states: {repr(self.get_states_1d().cpu().detach().numpy())}" + return f" class: {self.name} \n device name: {self.device_name} \n number of qubits: {self.n_wires} \n batch size: {self.bsz} \n current computing device: {self.density.device} \n recording op history: {self.record_op} \n current states: {repr(self.get_probs_1d().cpu().detach().numpy())}" ''' diff --git a/torchquantum/functional/gate_wrapper.py b/torchquantum/functional/gate_wrapper.py index 42889697..f1383f2f 100644 --- a/torchquantum/functional/gate_wrapper.py +++ b/torchquantum/functional/gate_wrapper.py @@ -8,8 +8,9 @@ from torchpack.utils.logging import logger from torchquantum.util import normalize_statevector + if TYPE_CHECKING: - from torchquantum.device import QuantumDevice + from torchquantum.device import QuantumDevice, NoiseDevice else: QuantumDevice = None @@ -58,7 +59,7 @@ def apply_unitary_einsum(state, mat, wires): # All affected indices will be summed over, so we need the same number # of new indices - new_indices = ABC[total_wires : total_wires + len(device_wires)] + new_indices = ABC[total_wires: total_wires + len(device_wires)] # The new indices of the state are given by the old ones with the # affected indices replaced by the new_indices @@ -139,17 +140,198 @@ def apply_unitary_bmm(state, mat, wires): return new_state +def apply_unitary_density_einsum(density, mat, wires): + """Apply the unitary to the densitymatrix using torch.einsum method. + + Args: + density (torch.Tensor): The densitymatrix. + mat (torch.Tensor): The unitary matrix of the operation. + wires (int or List[int]): Which qubit the operation is applied to. + + Returns: + torch.Tensor: The new statevector. + """ + + device_wires = wires + n_qubit = int((density.dim() - 1) / 2) + + # minus one because of batch + total_wires = len(density.shape) - 1 + + if len(mat.shape) > 2: + is_batch_unitary = True + bsz = mat.shape[0] + shape_extension = [bsz] + else: + is_batch_unitary = False + shape_extension = [] + + """ + Compute U \rho + """ + mat = mat.view(shape_extension + [2] * len(device_wires) * 2) + mat = mat.type(C_DTYPE).to(density.device) + if len(mat.shape) > 2: + # both matrix and state are in batch mode + # matdag is the dagger of mat + matdag = torch.conj(mat.permute([0, 2, 1])) + else: + # matrix no batch, state in batch mode + matdag = torch.conj(mat.permute([1, 0])) + + # Tensor indices of the quantum state + density_indices = ABC[:total_wires] + print("density_indices", density_indices) + + # Indices of the quantum state affected by this operation + affected_indices = "".join(ABC_ARRAY[list(device_wires)].tolist()) + print("affected_indices", affected_indices) + + # All affected indices will be summed over, so we need the same number + # of new indices + new_indices = ABC[total_wires: total_wires + len(device_wires)] + print("new_indices", new_indices) + + # The new indices of the state are given by the old ones with the + # affected indices replaced by the new_indices + new_density_indices = functools.reduce( + lambda old_string, idx_pair: old_string.replace(idx_pair[0], idx_pair[1]), + zip(affected_indices, new_indices), + density_indices, + ) + print("new_density_indices", new_density_indices) + + # Use the last literal as the indice of batch + density_indices = ABC[-1] + density_indices + new_density_indices = ABC[-1] + new_density_indices + if is_batch_unitary: + new_indices = ABC[-1] + new_indices + + # We now put together the indices in the notation numpy einsum + # requires + einsum_indices = ( + f"{new_indices}{affected_indices}," f"{density_indices}->{new_density_indices}" + ) + print("einsum_indices", einsum_indices) + + new_density = torch.einsum(einsum_indices, mat, density) + + """ + Compute U \rho U^\dagger + """ + print("dagger") + + # Tensor indices of the quantum state + density_indices = ABC[:total_wires] + print("density_indices", density_indices) + + # Indices of the quantum state affected by this operation + affected_indices = "".join( + ABC_ARRAY[[x + n_qubit for x in list(device_wires)]].tolist() + ) + print("affected_indices", affected_indices) + + # All affected indices will be summed over, so we need the same number + # of new indices + new_indices = ABC[total_wires: total_wires + len(device_wires)] + print("new_indices", new_indices) + + # The new indices of the state are given by the old ones with the + # affected indices replaced by the new_indices + new_density_indices = functools.reduce( + lambda old_string, idx_pair: old_string.replace(idx_pair[0], idx_pair[1]), + zip(affected_indices, new_indices), + density_indices, + ) + print("new_density_indices", new_density_indices) + + density_indices = ABC[-1] + density_indices + new_density_indices = ABC[-1] + new_density_indices + if is_batch_unitary: + new_indices = ABC[-1] + new_indices + + # We now put together the indices in the notation numpy einsum + # requires + einsum_indices = ( + f"{density_indices}," f"{affected_indices}{new_indices}->{new_density_indices}" + ) + print("einsum_indices", einsum_indices) + + new_density = torch.einsum(einsum_indices, density, matdag) + + return new_density + + +def apply_unitary_density_bmm(density, mat, wires): + """Apply the unitary to the DensityMatrix using torch.bmm method. + Args: + state (torch.Tensor): The statevector. + mat (torch.Tensor): The unitary matrix of the operation. + wires (int or List[int]): Which qubit the operation is applied to. + Returns: + torch.Tensor: The new statevector. + """ + device_wires = wires + n_qubit = density.dim() // 2 + mat = mat.type(C_DTYPE).to(density.device) + """ + Compute U \rho + """ + devices_dims = [w + 1 for w in device_wires] + permute_to = list(range(density.dim())) + for d in sorted(devices_dims, reverse=True): + del permute_to[d] + permute_to = permute_to[:1] + devices_dims + permute_to[1:] + permute_back = list(np.argsort(permute_to)) + original_shape = density.shape + permuted = density.permute(permute_to).reshape([original_shape[0], mat.shape[-1], -1]) + + if len(mat.shape) > 2: + # both matrix and state are in batch mode + new_density = mat.bmm(permuted) + else: + # matrix no batch, state in batch mode + bsz = permuted.shape[0] + expand_shape = [bsz] + list(mat.shape) + new_density = mat.expand(expand_shape).bmm(permuted) + new_density = new_density.view(original_shape).permute(permute_back) + """ + Compute \rho U^\dagger + """ + matdag = torch.conj(mat) + matdag = matdag.type(C_DTYPE).to(density.device) + + devices_dims_dag = [n_qubit + w + 1 for w in device_wires] + permute_to_dag = list(range(density.dim())) + for d in sorted(devices_dims_dag, reverse=True): + del permute_to_dag[d] + permute_to_dag = permute_to_dag + devices_dims_dag + permute_back_dag = list(np.argsort(permute_to_dag)) + permuted_dag = new_density.permute(permute_to_dag).reshape([original_shape[0], -1, matdag.shape[0]]) + + if len(matdag.shape) > 2: + # both matrix and state are in batch mode + new_density = permuted_dag.bmm(matdag) + else: + # matrix no batch, state in batch mode + bsz = permuted_dag.shape[0] + expand_shape = [bsz] + list(matdag.shape) + new_density = permuted_dag.bmm(matdag.expand(expand_shape)) + new_density = new_density.view(original_shape).permute(permute_back_dag) + return new_density + + def gate_wrapper( - name, - mat, - method, - q_device: QuantumDevice, - wires, - params=None, - n_wires=None, - static=False, - parent_graph=None, - inverse=False, + name, + mat, + method, + q_device: QuantumDevice, + wires, + params=None, + n_wires=None, + static=False, + parent_graph=None, + inverse=False, ): """Perform the phaseshift gate. @@ -249,8 +431,17 @@ def gate_wrapper( else: matrix = matrix.permute(1, 0) assert np.log2(matrix.shape[-1]) == len(wires) - state = q_device.states - if method == "einsum": - q_device.states = apply_unitary_einsum(state, matrix, wires) - elif method == "bmm": - q_device.states = apply_unitary_bmm(state, matrix, wires) + if q_device.device_name=="noisedevice": + density = q_device.densities + print(density.shape) + if method == "einsum": + return + elif method == "bmm": + q_device.densities = apply_unitary_density_bmm(density, matrix, wires) + else: + state = q_device.states + if method == "einsum": + q_device.states = apply_unitary_einsum(state, matrix, wires) + elif method == "bmm": + q_device.states = apply_unitary_bmm(state, matrix, wires) + From 1deef488cae54c8fc4f8868f4a0ea4abb2b6a195 Mon Sep 17 00:00:00 2001 From: Hanrui Wang Date: Sat, 3 Jun 2023 19:00:05 -0400 Subject: [PATCH 093/106] [minor] add an example of cuquantum --- examples/cuquantum/cuquantum_plugin.py | 74 ++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 examples/cuquantum/cuquantum_plugin.py diff --git a/examples/cuquantum/cuquantum_plugin.py b/examples/cuquantum/cuquantum_plugin.py new file mode 100644 index 00000000..ff8ceded --- /dev/null +++ b/examples/cuquantum/cuquantum_plugin.py @@ -0,0 +1,74 @@ +from cuquantum import contract +from cuquantum import CircuitToEinsum +import torchquantum as tq +from torchquantum.plugins import op_history2qiskit +from torchquantum.measurement import expval_joint_analytical +import cupy as cp + +def expval_joint_analytical_cuquantum(qdev, observable): + """Computes the expectation value of a joint observable using cuquantum. + + Args: + qdev (QuantumDevice): Quantum device to compute the expectation value on. + observable (str): Joint observable to compute the expectation value of. + + Returns: + float: The expectation value of the joint observable. + """ + op_history = qdev.op_history + qiskit_circ = op_history2qiskit(qdev.n_wires, op_history) + myconverter = CircuitToEinsum(qiskit_circ, dtype='complex128', backend=cp) + expression, operands = myconverter.expectation(observable, lightcone=True) + expec = contract(expression, *operands) + return expec + + +if __name__ == '__main__': + + ops = [ + {'name': 'u3', 'wires': 0, 'trainable': True}, + {'name': 'u3', 'wires': 1, 'trainable': True}, + {'name': 'cx', 'wires': [0, 1]}, + {'name': 'cx', 'wires': [1, 0]}, + {'name': 'u3', 'wires': 0, 'trainable': True}, + {'name': 'u3', 'wires': 1, 'trainable': True}, + {'name': 'cx', 'wires': [0, 1]}, + {'name': 'cx', 'wires': [1, 0]}, + ] + + qmodule = tq.QuantumModule.from_op_history(ops) + + qdev = tq.QuantumDevice(n_wires=2, bsz=1, record_op=True) + + qmodule(qdev) + + op_history = qdev.op_history + + # print(op_history) + + qiskit_circ = op_history2qiskit(qdev.n_wires, op_history) + # print(qiskit_circ) + + myconverter = CircuitToEinsum(qiskit_circ, dtype='complex128', backend=cp) + pauli_string = 'IX' + expression, operands = myconverter.expectation(pauli_string, lightcone=True) + expec = contract(expression, *operands) + print(f'expectation value for {pauli_string}: {expec}') + + print(f"torchquantum expval: {expval_joint_analytical(qdev, pauli_string)}") + print(expval_joint_analytical_cuquantum(qdev, pauli_string)) + + + # # expectation value from reduced density matrix + # qubits = myconverter.qubits + # where = qubits[1:5] + # rdm_expression, rdm_operands = myconverter.reduced_density_matrix(where, lightcone=True) + # rdm = contract(rdm_expression, *rdm_operands) + + # pauli_x = cp.asarray([[0,1],[1,0]], dtype=myconverter.dtype) + # pauli_z = cp.asarray([[1,0],[0,-1]], dtype=myconverter.dtype) + # expec_from_rdm = cp.einsum('abcdABCD,aA,bB,cC,dD->', rdm, pauli_x, pauli_x, pauli_z, pauli_z) + + + # print(f"is expectation value in agreement?", cp.allclose(expec, expec_from_rdm)) + From 915491f9afa607737b1036c4f13f448f5d1e1ab5 Mon Sep 17 00:00:00 2001 From: Hanrui Wang Date: Sat, 3 Jun 2023 19:26:20 -0400 Subject: [PATCH 094/106] [minor] update ibm util --- torchquantum/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/torchquantum/utils.py b/torchquantum/utils.py index 2f7f9310..9826ac83 100644 --- a/torchquantum/utils.py +++ b/torchquantum/utils.py @@ -530,13 +530,13 @@ def get_provider(backend_name, hub=None): except QiskitError: # logger.warning(f"Cannot use MIT backend, roll back to open") logger.warning(f"Use the open backend") - provider = IBMQ.get_provider(hub="ibm-q") + provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main") elif hub == "mit": provider = IBMQ.get_provider( hub="ibm-q-research", group="MIT-1", project="main" ) else: - provider = IBMQ.get_provider(hub="ibm-q") + provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main") return provider From 958e41fd193011161280166456cacc6947688726 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sat, 27 Jan 2024 18:58:21 -0500 Subject: [PATCH 095/106] [minor] rm rebase bug --- examples/cuquantum/cuquantum_plugin.py | 1 - 1 file changed, 1 deletion(-) diff --git a/examples/cuquantum/cuquantum_plugin.py b/examples/cuquantum/cuquantum_plugin.py index 832b1ff0..f31665e8 100644 --- a/examples/cuquantum/cuquantum_plugin.py +++ b/examples/cuquantum/cuquantum_plugin.py @@ -1,4 +1,3 @@ -<<<<<<< HEAD """ MIT License From c9ed61fd089fc5321171c0d3427949413039d440 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 28 Jan 2024 17:56:56 -0500 Subject: [PATCH 096/106] [minor] rm init to get tests working --- test/__init__.py | 25 ------------------------- 1 file changed, 25 deletions(-) delete mode 100644 test/__init__.py diff --git a/test/__init__.py b/test/__init__.py deleted file mode 100644 index 6dadfb34..00000000 --- a/test/__init__.py +++ /dev/null @@ -1,25 +0,0 @@ -""" -MIT License - -Copyright (c) 2020-present TorchQuantum Authors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -""" - -from .utils import * From 2c3a6f811eb5672a739bdfd07bb263aac393b988 Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Sun, 28 Jan 2024 18:04:12 -0500 Subject: [PATCH 097/106] [minor] changing the way pytest is run to try to change the error --- .github/workflows/functional_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index af549120..fb8a7ea1 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -35,4 +35,4 @@ jobs: flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | - pytest -m "not skip" + python -m pytest -m "not skip" From 75bd6ce89dc96ae8e575894f372ad38d8add5543 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Sun, 28 Jan 2024 19:58:01 -0500 Subject: [PATCH 098/106] [minor] readding init to try to fix the tests --- test/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 test/__init__.py diff --git a/test/__init__.py b/test/__init__.py new file mode 100644 index 00000000..e69de29b From 8254fd1025223e72cdcbd102d1d19861826f832f Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Sat, 10 Feb 2024 22:12:38 -0500 Subject: [PATCH 099/106] [minor] update OneQubitEulerDecomposer --- torchquantum/plugin/qiskit/qiskit_unitary_gate.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torchquantum/plugin/qiskit/qiskit_unitary_gate.py b/torchquantum/plugin/qiskit/qiskit_unitary_gate.py index 6e520b96..ce46ff04 100644 --- a/torchquantum/plugin/qiskit/qiskit_unitary_gate.py +++ b/torchquantum/plugin/qiskit/qiskit_unitary_gate.py @@ -25,7 +25,7 @@ from qiskit.circuit.library.standard_gates import U3Gate from qiskit.quantum_info.operators.predicates import matrix_equal from qiskit.quantum_info.operators.predicates import is_unitary_matrix -from qiskit.quantum_info.synthesis.one_qubit_decompose import OneQubitEulerDecomposer +from qiskit.quantum_info import OneQubitEulerDecomposer from qiskit.quantum_info.synthesis.two_qubit_decompose import two_qubit_cnot_decompose from qiskit.extensions.exceptions import ExtensionError From 0f648675befdcac672d6557f1916e7073d900992 Mon Sep 17 00:00:00 2001 From: GenericP3rson <41024739+GenericP3rson@users.noreply.github.com> Date: Sat, 17 Feb 2024 22:39:09 -0500 Subject: [PATCH 100/106] [minor] lower the qiskit version --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 88a06d50..a43fc839 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,7 +8,7 @@ opt_einsum pathos>=0.2.7 pylatexenc>=2.10 pyscf>=2.0.1 -qiskit>=0.39.0 +qiskit>=0.39.0,<1.0.0 recommonmark scipy>=1.5.2 From 0b0097906ccc8509ddc7ff7d9a59e319c5918e09 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Tue, 20 Feb 2024 19:09:46 -0500 Subject: [PATCH 101/106] [major] removed deprecated IBMQ dependency and restricted to qiskit<1.0.0 --- torchquantum/util/utils.py | 33 ++++++++++----------------------- 1 file changed, 10 insertions(+), 23 deletions(-) diff --git a/torchquantum/util/utils.py b/torchquantum/util/utils.py index 58ef4e03..caeee471 100644 --- a/torchquantum/util/utils.py +++ b/torchquantum/util/utils.py @@ -30,7 +30,7 @@ import torch.nn as nn import torch.nn.functional as F from opt_einsum import contract -from qiskit import IBMQ +from qiskit_ibm_runtime import QiskitRuntimeService from qiskit.exceptions import QiskitError from qiskit.providers.aer.noise.device.parameters import gate_error_values from torchpack.utils.config import Config @@ -738,7 +738,6 @@ def get_success_rate(properties, transpiled_circ): return success_rate - def get_provider(backend_name, hub=None): """ Get the provider object for a specific backend from IBM Quantum. @@ -753,13 +752,9 @@ def get_provider(backend_name, hub=None): # mass-inst-tech-1 or MIT-1 if backend_name in ["ibmq_casablanca", "ibmq_rome", "ibmq_bogota", "ibmq_jakarta"]: if hub == "mass" or hub is None: - provider = IBMQ.get_provider( - hub="ibm-q-research", group="mass-inst-tech-1", project="main" - ) + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q-research/mass-inst-tech-1/main") elif hub == "mit": - provider = IBMQ.get_provider( - hub="ibm-q-research", group="MIT-1", project="main" - ) + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q-research/MIT-1/main") else: raise ValueError(f"not supported backend {backend_name} in hub " f"{hub}") elif backend_name in [ @@ -769,33 +764,25 @@ def get_provider(backend_name, hub=None): "ibmq_guadalupe", "ibmq_montreal", ]: - provider = IBMQ.get_provider(hub="ibm-q-ornl", group="anl", project="csc428") + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q-ornl/anl/csc428") else: if hub == "mass" or hub is None: try: - provider = IBMQ.get_provider( - hub="ibm-q-research", group="mass-inst-tech-1", project="main" - ) + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q-research/mass-inst-tech-1/main") except QiskitError: # logger.warning(f"Cannot use MIT backend, roll back to open") logger.warning(f"Use the open backend") - provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main") + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q/open/main") elif hub == "mit": - provider = IBMQ.get_provider( - hub="ibm-q-research", group="MIT-1", project="main" - ) + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q-research/MIT-1/main") else: - provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main") + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = "ibm-q/open/main") return provider def get_provider_hub_group_project(hub="ibm-q", group="open", project="main"): - provider = IBMQ.get_provider( - hub=hub, - group=group, - project=project, - ) + provider = QiskitRuntimeService(channel = "ibm_quantum", instance = f"{hub}/{group}/{project}") return provider @@ -1085,4 +1072,4 @@ def clone_model(model_to_clone):#i have to note:this clone_model function was ma state_dict_minus_shift[key] += shift_rate gradient_of_par[idx-2] = (expectation_plus_shift - expectation_minus_shift) * 0.5 - return gradient_of_par \ No newline at end of file + return gradient_of_par From b9851929743fab7272a7ec037d949f26c3e75923 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Tue, 20 Feb 2024 19:28:09 -0500 Subject: [PATCH 102/106] [minor] added missing dependency --- .github/workflows/functional_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index fb8a7ea1..f1d2770e 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -25,7 +25,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install flake8 pytest qiskit-aer qiskit-ibmq-provider + python -m pip install flake8 pytest qiskit-aer qiskit_ibm_runtime if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Lint with flake8 run: | From 1f7bcf0866ff830dab93f27aa26f24f6c445f7a0 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Tue, 20 Feb 2024 19:37:47 -0500 Subject: [PATCH 103/106] [minor] flipping order of imports --- .github/workflows/functional_tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/functional_tests.yaml b/.github/workflows/functional_tests.yaml index f1d2770e..4be0f73d 100644 --- a/.github/workflows/functional_tests.yaml +++ b/.github/workflows/functional_tests.yaml @@ -25,8 +25,8 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install flake8 pytest qiskit-aer qiskit_ibm_runtime if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + python -m pip install flake8 pytest qiskit-aer qiskit_ibm_runtime - name: Lint with flake8 run: | # stop the build if there are Python syntax errors or undefined names From d6fffa184ec8a3c1f1cf299ca5814c3e392c7926 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Tue, 20 Feb 2024 19:42:34 -0500 Subject: [PATCH 104/106] [minor] updating the requirements --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 88a06d50..a43fc839 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,7 +8,7 @@ opt_einsum pathos>=0.2.7 pylatexenc>=2.10 pyscf>=2.0.1 -qiskit>=0.39.0 +qiskit>=0.39.0,<1.0.0 recommonmark scipy>=1.5.2 From 529436663cac49eb40a08f340c72999b5df00e16 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Tue, 20 Feb 2024 20:22:46 -0500 Subject: [PATCH 105/106] [major] update documentation deployment --- docs/requirements.txt | 6 ++++++ docs/source/conf.py | 3 +-- readthedocs.yaml | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 42 insertions(+), 2 deletions(-) create mode 100644 docs/requirements.txt create mode 100644 readthedocs.yaml diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 00000000..597c0496 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,6 @@ +furo @ git+https://github.com/frogcjn/torchquantum-doc-furo-theme.git +nbsphinx +recommonmark + +torchquantum>=0.1 +opt_einsum diff --git a/docs/source/conf.py b/docs/source/conf.py index 86fbdc7a..537edece 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -29,7 +29,6 @@ import sys import os sys.path.insert(0, os.path.abspath('../..')) -import furo #import pathlib #sys.path.insert(0, pathlib.Path(__file__).parents[2].resolve().as_posix()) @@ -160,4 +159,4 @@ display_gitlab = False show_source = True # -- Options for EPUB output -epub_show_urls = 'footnote' \ No newline at end of file +epub_show_urls = 'footnote' diff --git a/readthedocs.yaml b/readthedocs.yaml new file mode 100644 index 00000000..b664f319 --- /dev/null +++ b/readthedocs.yaml @@ -0,0 +1,35 @@ +# Read the Docs configuration file for Sphinx projects +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the OS, Python version and other tools you might need +build: + os: ubuntu-22.04 + tools: + python: "3.10" + # You can also specify other tool versions: + # nodejs: "20" + # rust: "1.70" + # golang: "1.20" + +# Build documentation in the "docs/" directory with Sphinx +sphinx: + configuration: docs/source/conf.py + # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs + # builder: "dirhtml" + # Fail on all warnings to avoid broken references + # fail_on_warning: true + +# Optionally build your docs in additional formats such as PDF and ePub +# formats: +# - pdf +# - epub + +# Optional but recommended, declare the Python requirements required +# to build your documentation +# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html +python: + install: + - requirements: docs/requirements.txt From 8f3421b3af518e0d035ed90b96e9a2d615c8d589 Mon Sep 17 00:00:00 2001 From: GenericP3rson Date: Tue, 20 Feb 2024 20:37:16 -0500 Subject: [PATCH 106/106] [minor] adding the missing dependency --- docs/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/requirements.txt b/docs/requirements.txt index 597c0496..063be65a 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -4,3 +4,4 @@ recommonmark torchquantum>=0.1 opt_einsum +qiskit_ibm_runtime