classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -1,5 +1,6 @@
 import itertools
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 import torch
 from torch import Tensor

classiq/applications/qnn/qlayer.py

@@ -1,11 +1,13 @@
 import functools
-from typing import Any, Callable, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 import torch
 import torch.nn as nn
 from torch import Tensor
 from torch.nn.parameter import Parameter
 
+from classiq.interface.exceptions import ClassiqQNNError, ClassiqTorchError
+
 from classiq.applications.qnn.circuit_utils import (
     extract_parameters,
     is_single_layer_circuit,
@@ -13,6 +15,7 @@ from classiq.applications.qnn.circuit_utils import (
     validate_circuit,
 )
 from classiq.applications.qnn.gradients.simple_quantum_gradient import (
+    EPSILON,
     SimpleQuantumGradient,
 )
 from classiq.applications.qnn.torch_utils import (
@@ -26,7 +29,6 @@ from classiq.applications.qnn.types import (
     MultipleArguments,
     PostProcessFunction,
 )
-from classiq.exceptions import ClassiqQNNError, ClassiqTorchError
 from classiq.synthesis import SerializedQuantumProgram
 
 
@@ -39,6 +41,7 @@ class QLayerFunction(torch.autograd.Function):
         quantum_program: SerializedQuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
+        epsilon: Optional[float] = EPSILON,
     ) -> Tensor:
         """
         This function receives:
@@ -51,7 +54,9 @@ class QLayerFunction(torch.autograd.Function):
                 and returning a `Tensor`
 
         """
-        circuit = Circuit.parse_raw(quantum_program)
+        if epsilon is None:
+            epsilon = EPSILON
+        circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         # save for backward
@@ -60,7 +65,7 @@ class QLayerFunction(torch.autograd.Function):
         ctx.execute = execute
         ctx.post_process = post_process
         ctx.quantum_gradient = SimpleQuantumGradient(
-            quantum_program, execute, post_process
+            quantum_program, execute, post_process, epsilon
         )
 
         ctx.batch_size, ctx.num_in_features = inputs.shape
@@ -94,7 +99,7 @@ class QLayerFunction(torch.autograd.Function):
     @staticmethod
     def backward(  # type: ignore[override]
         ctx: Any, grad_output: Tensor
-    ) -> Tuple[Optional[Tensor], Optional[Tensor], None, None, None]:
+    ) -> tuple[Optional[Tensor], Optional[Tensor], None, None, None, None]:
         """
         grad_output: Tensor
             is of shape (ctx.batch_size, ctx.num_out_features)
@@ -103,6 +108,7 @@ class QLayerFunction(torch.autograd.Function):
 
         grad_weights = grad_inputs = None
         grad_circuit = grad_execute = grad_post_process = None
+        grad_epsilon = None
         is_single_layer = is_single_layer_circuit(weights)
 
         if ctx.needs_input_grad[1]:
@@ -118,7 +124,14 @@ class QLayerFunction(torch.autograd.Function):
                 f"Grad required for unknown type: {ctx.needs_input_grad}"
             )
 
-        return grad_inputs, grad_weights, grad_circuit, grad_execute, grad_post_process
+        return (
+            grad_inputs,
+            grad_weights,
+            grad_circuit,
+            grad_execute,
+            grad_post_process,
+            grad_epsilon,
+        )
 
 
 CalcNumOutFeatures = Callable[[SerializedQuantumProgram], int]
@@ -142,8 +155,9 @@ class QLayer(nn.Module):
         head_start: Union[float, Tensor, None] = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
+        epsilon: float = EPSILON,
     ) -> None:
-        circuit = Circuit.parse_raw(quantum_program)
+        circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         super().__init__()
@@ -151,6 +165,7 @@ class QLayer(nn.Module):
         self._execute = execute
         self._post_process = post_process
         self._head_start = head_start
+        self._epsilon = epsilon
 
         self.quantum_program = quantum_program
 
@@ -161,7 +176,7 @@ class QLayer(nn.Module):
         self._initialize_parameters()
 
     def _initialize_parameters(self) -> None:
-        shape: Tuple[int, ...] = (
+        shape: tuple[int, ...] = (
             (self.out_features, self.in_features)
             if self.out_features > 1
             else (self.in_features,)
@@ -181,6 +196,11 @@ class QLayer(nn.Module):
         self.weight = Parameter(value)
 
     def forward(self, x: Tensor) -> Tensor:
-        return QLayerFunction.apply(  # type: ignore[no-untyped-call]
-            x, self.weight, self.quantum_program, self._execute, self._post_process
+        return QLayerFunction.apply(
+            x,
+            self.weight,
+            self.quantum_program,
+            self._execute,
+            self._post_process,
+            self._epsilon,
         )

classiq/applications/qnn/torch_utils.py

@@ -1,11 +1,13 @@
 from collections.abc import Sized
 from functools import reduce
-from typing import Optional, Tuple
+from typing import Optional
 
 import torch
 import torch.nn as nn
 from torch import Tensor
 
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.applications.qnn.circuit_utils import is_single_layer_circuit
 from classiq.applications.qnn.types import (
     ExecuteFuncitonOnlyArguments,
@@ -13,7 +15,6 @@ from classiq.applications.qnn.types import (
     Shape,
     TensorToArgumentsCallable,
 )
-from classiq.exceptions import ClassiqValueError
 
 
 def get_shape_second_dimension(shape: torch.Size) -> int:
@@ -97,7 +98,7 @@ def iter_inputs_weights(
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))
-        inputs_weights_shape: Tuple[int, ...] = (inputs.shape[0],)
+        inputs_weights_shape: tuple[int, ...] = (inputs.shape[0],)
     else:
         iter_weights = weights
         inputs_weights_shape = (inputs.shape[0], weights.shape[0])

classiq/applications/qnn/types.py

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 import torch
 from torch import Tensor
@@ -8,8 +8,8 @@ from classiq.interface.executor.execution_result import ResultsCollection, Saved
 from classiq import QuantumProgram
 from classiq.synthesis import SerializedQuantumProgram
 
-Arguments = Dict[str, float]
-MultipleArguments = Tuple[Arguments, ...]
+Arguments = dict[str, float]
+MultipleArguments = tuple[Arguments, ...]
 
 Circuit = QuantumProgram
 ExecuteFunction = Callable[
@@ -19,10 +19,10 @@ ExecuteFuncitonOnlyArguments = Callable[[MultipleArguments], ResultsCollection]
 PostProcessFunction = Callable[[SavedResult], Tensor]
 TensorToArgumentsCallable = Callable[[Tensor, Tensor], MultipleArguments]
 
-Shape = Union[torch.Size, Tuple[int, ...]]
+Shape = Union[torch.Size, tuple[int, ...]]
 
 GradientFunction = Callable[[Tensor, Tensor], Tensor]
 SimulateFunction = Callable[[Tensor, Tensor], Tensor]
 
-DataAndLabel = Tuple[List[int], Union[List[int], int]]
+DataAndLabel = tuple[list[int], Union[list[int], int]]
 Transform = Callable[[Tensor], Tensor]

classiq/applications/qsvm/__init__.py

@@ -1,8 +1,10 @@
-from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement import (
-    QSVMFeatureMapEntanglement,
-)
+from classiq.qmod.builtins.enums import QSVMFeatureMapEntanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
+from .qsvm_model_constructor import construct_qsvm_model
 
-__all__ = ["QSVMFeatureMapEntanglement"]
+__all__ = [
+    "QSVMFeatureMapEntanglement",
+    "construct_qsvm_model",
+]

classiq/applications/qsvm/qsvm.py

@@ -1,14 +1,11 @@
-from typing import List
-
-from classiq.interface.applications.qsvm import Data, Labels, QSVMData, QSVMPreferences
+from classiq.interface.applications.qsvm import Data, Labels, QSVMData
 
 __all__ = [
-    "QSVMData",
-    "QSVMPreferences",
     "Data",
     "Labels",
+    "QSVMData",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/qsvm/qsvm_data_generation.py

@@ -1,6 +1,6 @@
 import logging
 from collections import defaultdict
-from typing import Dict, Optional, Tuple
+from typing import Optional
 
 import numpy as np
 
@@ -15,7 +15,7 @@ def generate_data(
     range_max: float = 2 * np.pi,
     std: float = 0.5,
     sources: Optional[np.ndarray] = None,
-) -> Dict[int, np.ndarray]:
+) -> dict[int, np.ndarray]:
     if sources is None:
         sources = np.random.uniform(
             range_min, range_max, (amount_of_sources, dimension)
@@ -36,7 +36,7 @@ def generate_data(
     return results
 
 
-def data_dict_to_data_and_labels(data_dict: dict) -> Tuple[np.ndarray, np.ndarray]:
+def data_dict_to_data_and_labels(data_dict: dict) -> tuple[np.ndarray, np.ndarray]:
     data = []
     labels = []
     for k, v in data_dict.items():

classiq/{applications_model_constructors → applications/qsvm}/qsvm_model_constructor.py

@@ -1,21 +1,21 @@
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
-from classiq.interface.generator.expressions.enums.pauli import Pauli
-from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement import (
-    QSVMFeatureMapEntanglement,
-)
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq.exceptions import ClassiqValueError
+from classiq.qmod.builtins.enums import Pauli, QSVMFeatureMapEntanglement
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 INVALID_FEATURE_MAP_FUNC_NAME_MSG = "Invalid feature_map_function_name, it can be bloch_sphere_feature_map or pauli_feature_map"
 
@@ -24,43 +24,46 @@ _OUTPUT_VARIABLE_NAME = "qsvm_results"
 
 def _bloch_sphere_feature_map_function_params(
     bloch_feature_dimension: int,
-) -> Tuple[Dict[str, Expression], str]:
-    return {
-        "feature_dimension": Expression(expr=f"{bloch_feature_dimension}")
-    }, f"ceiling({bloch_feature_dimension}/2)"
+) -> tuple[list[Expression], str]:
+    return [
+        Expression(expr=f"{bloch_feature_dimension}")
+    ], f"ceiling({bloch_feature_dimension}/2)"
 
 
 def _pauli_feature_map_function_params(
-    paulis: List[List[Pauli]],
+    paulis: list[list[Pauli]],
     entanglement: QSVMFeatureMapEntanglement,
     alpha: int,
     reps: int,
     feature_dimension: int,
-) -> Tuple[Dict[str, Expression], str]:
+) -> tuple[list[Expression], str]:
     paulis_str = (
         "["
         + ",".join(
-            ["[" + ",".join([str(p) for p in p_list]) + "]" for p_list in paulis]
+            [
+                "[" + ",".join([qmod_val_to_expr_str(p) for p in p_list]) + "]"
+                for p_list in paulis
+            ]
         )
         + "]"
     )
     pauli_feature_map_params = (
         f"paulis={paulis_str}, "
-        f"entanglement={entanglement}, "
+        f"entanglement={qmod_val_to_expr_str(entanglement)}, "
         f"alpha={alpha}, "
         f"reps={reps}, "
         f"feature_dimension={feature_dimension}"
     )
-    return {
-        "feature_map": Expression(
+    return [
+        Expression(
             expr=f"struct_literal(QSVMFeatureMapPauli, {pauli_feature_map_params})"
         )
-    }, f"{feature_dimension}"
+    ], f"{feature_dimension}"
 
 
 def get_qsvm_qmain_body(
     feature_map_function_name: str, **kwargs: Any
-) -> List[QuantumFunctionCall]:
+) -> list[QuantumStatement]:
     if feature_map_function_name == "bloch_sphere_feature_map":
         params, size_expr = _bloch_sphere_feature_map_function_params(**kwargs)
     elif feature_map_function_name == "pauli_feature_map":
@@ -69,14 +72,13 @@ def get_qsvm_qmain_body(
         raise ClassiqValueError(INVALID_FEATURE_MAP_FUNC_NAME_MSG)
 
     return [
-        QuantumFunctionCall(
-            function="allocate",
-            positional_args=[Expression(expr=size_expr), HandleBinding(name="qbv")],
+        Allocate(
+            size=Expression(expr=size_expr),
+            target=HandleBinding(name="qbv"),
         ),
         QuantumFunctionCall(
             function=feature_map_function_name,
-            params=params,
-            inouts={"qbv": HandleBinding(name="qbv")},
+            positional_args=[*params, HandleBinding(name="qbv")],
         ),
     ]
 
@@ -94,12 +96,12 @@ def construct_qsvm_model(
         functions=[
             NativeFunctionDefinition(
                 name="main",
-                port_declarations={
-                    "qbv": PortDeclaration(
+                positional_arg_declarations=[
+                    PortDeclaration(
                         name="qbv",
                         direction=PortDeclarationDirection.Output,
-                    )
-                },
+                    ),
+                ],
                 body=get_qsvm_qmain_body(
                     feature_map_function_name=feature_map_function_name, **kwargs
                 ),
@@ -114,7 +116,7 @@ def construct_qsvm_model(
     predict_data={predict_data}
 )
 save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
+""".strip(),
     )
 
     return qsvm_qmod.get_model()

classiq/execution/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ..executor import *  # noqa: F403
 from ..executor import __all__ as _exec_all
 from ..interface.backend.backend_preferences import *  # noqa: F403
@@ -9,7 +7,10 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.iqae_result import IQAEResult
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
+from .execution_session import ExecutionSession
+from .iqcc import generate_iqcc_token, generate_iqcc_token_async
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
+from .qnn import execute_qnn
 
 __all__ = (
     _be_all
@@ -22,9 +23,13 @@ __all__ = (
         "ExecutionJob",
         "get_execution_jobs",
         "get_execution_jobs_async",
+        "ExecutionSession",
+        "execute_qnn",
+        "generate_iqcc_token",
+        "generate_iqcc_token_async",
     ]
 )
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/execution/all_hardware_devices.py

@@ -0,0 +1,11 @@
+from classiq.interface.hardware import HardwareInformation
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+
+
+def get_all_hardware_devices() -> list[HardwareInformation]:
+    """
+    Returns a list of all hardware devices known to Classiq.
+    """
+    return async_utils.run(ApiWrapper.call_get_all_hardware_devices())