classiq 0.94.2__py3-none-any.whl → 0.96.0__py3-none-any.whl

classiq/interface/applications/qsvm.py

@@ -1,114 +0,0 @@
-from collections.abc import Iterable as IterableType, Sequence
-from typing import (
-    Any,
-    Union,
-)
-
-import numpy as np
-import pydantic
-from numpy.typing import ArrayLike
-from pydantic import ConfigDict, field_validator
-
-from classiq.interface.helpers.versioned_model import VersionedModel
-
-DataList = list[list[float]]
-LabelsInt = list[int]
-
-
-def listify(obj: IterableType | ArrayLike) -> list:
-    if isinstance(obj, np.ndarray):
-        return obj.tolist()
-    elif isinstance(obj, Sequence) and obj and isinstance(obj[0], np.ndarray):
-        return np.array(obj).tolist()
-    elif isinstance(obj, list):
-        return obj
-    else:
-        return list(obj)  # type: ignore[arg-type]
-
-
-def validate_array_to_list(name: str) -> Any:
-    @field_validator(name, mode="before")
-    def _listify(cls: type[pydantic.BaseModel], value: Any) -> Any:
-        return listify(value)
-
-    return _listify
-
-
-Shape = tuple[int, ...]
-
-
-class QSVMInternalState(VersionedModel):
-    underscore_sparse: bool
-    class_weight: list
-    classes: list
-    underscore_gamma: float
-    underscore_base_fit: list
-    support: list
-    support_vectors: list
-    underscore_n_support: list
-    dual_coef_2: list
-    intercept: list
-    underscore_p_a: list
-    underscore_p_b: list
-    fit_status: int
-    shape_fit: Shape
-    underscore_intercept: list
-    dual_coef: list
-
-    class_weight__shape: Shape
-    classes__shape: Shape
-    underscore_base_fit__shape: Shape
-    support__shape: Shape
-    support_vectors__shape: Shape
-    underscore_n_support__shape: Shape
-    dual_coef_2__shape: Shape
-    intercept__shape: Shape
-    underscore_p_a__shape: Shape
-    underscore_p_b__shape: Shape
-    underscore_intercept__shape: Shape
-    dual_coef__shape: Shape
-
-    set_class_weight = validate_array_to_list("class_weight")
-    set_classes = validate_array_to_list("classes")
-    set_underscore_base_fit = validate_array_to_list("underscore_base_fit")
-    set_support = validate_array_to_list("support")
-    set_support_vectors = validate_array_to_list("support_vectors")
-    set_underscore_n_support = validate_array_to_list("underscore_n_support")
-    set_dual_coef_2 = validate_array_to_list("dual_coef_2")
-    set_intercept = validate_array_to_list("intercept")
-    set_underscore_p_a = validate_array_to_list("underscore_p_a")
-    set_underscore_p_b = validate_array_to_list("underscore_p_b")
-    set_underscore_intercept = validate_array_to_list("underscore_intercept")
-    set_dual_coef = validate_array_to_list("dual_coef")
-
-
-class QSVMData(VersionedModel):
-    data: DataList
-    labels: LabelsInt | None = None
-    internal_state: QSVMInternalState | None = None
-    model_config = ConfigDict(extra="forbid")
-
-    @pydantic.field_validator("data", mode="before")
-    @classmethod
-    def set_data(cls, data: IterableType | ArrayLike) -> list:
-        return listify(data)
-
-    @pydantic.field_validator("labels", mode="before")
-    @classmethod
-    def set_labels(cls, labels: IterableType | ArrayLike | None) -> list | None:
-        if labels is None:
-            return None
-        else:
-            return listify(labels)
-
-
-class QSVMTestResult(VersionedModel):
-    data: float  # between 0 to 1
-
-
-class QSVMPredictResult(VersionedModel):
-    data: list  # serialized np.array
-
-
-Data = Union[DataList, np.ndarray]
-Labels = Union[list[Any], np.ndarray]

classiq/interface/execution/iqcc.py

@@ -1,42 +0,0 @@
-from pydantic import BaseModel, Field
-
-from classiq.interface.helpers.versioned_model import VersionedModel
-
-
-class IQCCInitAuthData(VersionedModel):
-    auth_scope_id: str
-    auth_method_id: str
-
-
-class IQCCInitAuthResponse(VersionedModel):
-    auth_url: str
-    token_id: str
-
-
-class IQCCProbeAuthData(IQCCInitAuthData):
-    token_id: str
-
-
-class IQCCProbeAuthResponse(VersionedModel):
-    auth_token: str
-
-
-class IQCCAuthItemDetails(BaseModel):
-    id: str
-    name: str
-    description: str
-    scope_id: str | None = Field(default=None)
-
-
-class IQCCAuthItemsDetails(VersionedModel):
-    items: list[IQCCAuthItemDetails]
-
-
-class IQCCListAuthMethods(VersionedModel):
-    auth_scope_id: str
-
-
-class IQCCListAuthTargets(VersionedModel):
-    auth_scope_id: str
-    auth_method_id: str
-    auth_token: str

classiq/interface/generator/application_apis/qsvm_declarations.py

@@ -1,6 +0,0 @@
-import enum
-
-
-class FeatureMapType(enum.Enum):
-    BlochSphere = "bloch_sphere"
-    Pauli = "pauli"

classiq/interface/generator/qsvm.py

@@ -1,96 +0,0 @@
-from typing import Literal, Union
-
-import numpy as np
-import pydantic
-from pydantic import ConfigDict
-
-from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqQSVMError, ClassiqValueError
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-    FunctionParams,
-)
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-VALID_PAULI_LETTERS = ("I", "X", "Y", "Z")
-
-
-class QSVMFeatureMapEntanglement(StrEnum):
-    FULL = "full"
-    LINEAR = "linear"
-    CIRCULAR = "circular"
-    SCA = "sca"
-    PAIRWISE = "pairwise"
-
-
-class QSVMFeatureMapDimensional(HashablePydanticBaseModel):
-    feature_dimension: int | None = None
-    model_config = ConfigDict(frozen=True)
-
-
-class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
-    map_type: Literal["pauli_feature_map"] = pydantic.Field(default="pauli_feature_map")
-    reps: int = 2
-    entanglement: QSVMFeatureMapEntanglement = QSVMFeatureMapEntanglement.LINEAR
-    alpha: float = 2.0
-    paulis: list[str] = ["Z", "ZZ"]
-    parameter_prefix: str = "x"
-    name: str = "PauliFeatureMap"
-
-    @pydantic.field_validator("paulis", mode="before")
-    @classmethod
-    def set_paulis(cls, paulis: list[str]) -> list[str]:
-        # iterate every letter in every string in the list of paulis
-        for s in paulis:
-            if not all(map(VALID_PAULI_LETTERS.__contains__, s.upper())):
-                raise ClassiqValueError(
-                    f"Invalid pauli string given: {s!r}. Expecting a combination of {VALID_PAULI_LETTERS}"
-                )
-        return list(map(str.upper, paulis))
-
-
-class QSVMFeatureMapBlochSphere(QSVMFeatureMapDimensional):
-    map_type: Literal["bloch_sphere_feature_map"] = pydantic.Field(
-        default="bloch_sphere_feature_map"
-    )
-
-
-FeatureMapType = Union[QSVMFeatureMapBlochSphere, QSVMFeatureMapPauli]
-
-
-class QSVMFeatureMap(FunctionParams):
-    """
-    Feature map circuit used for QSVM
-    """
-
-    feature_map: FeatureMapType = pydantic.Field(
-        description="The feature map for the qsvm",
-        discriminator="map_type",
-    )
-
-    @property
-    def num_qubits(self) -> int:
-        if not self.feature_map.feature_dimension:
-            raise ClassiqQSVMError(
-                "Feature dimension should be provided to create a circuit."
-            )
-        if isinstance(self.feature_map, QSVMFeatureMapPauli):
-            return self.feature_map.feature_dimension
-        else:
-            return int(np.ceil(self.feature_map.feature_dimension / 2))
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            DEFAULT_INPUT_NAME: RegisterUserInput(
-                name=DEFAULT_INPUT_NAME, size=self.num_qubits
-            )
-        }
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterUserInput(
-                name=DEFAULT_OUTPUT_NAME, size=self.num_qubits
-            )
-        }

classiq/open_library/functions/lookup_table.py

@@ -1,58 +0,0 @@
-from itertools import product
-
-from classiq.interface.exceptions import ClassiqValueError
-
-from classiq.qmod.builtins.operations import assign, bind, within_apply
-from classiq.qmod.qmod_variable import QNum
-from classiq.qmod.symbolic import subscript
-from classiq.qmod.utilities import RealFunction, get_temp_var_name, qnum_values
-
-
-def _get_qnum_values(num: QNum) -> list[float]:
-    size = num.size
-    is_signed = num.is_signed
-    fraction_digits = num.fraction_digits
-    if (
-        not isinstance(size, int)
-        or not isinstance(is_signed, bool)
-        or not isinstance(fraction_digits, int)
-    ):
-        raise ClassiqValueError(
-            "Must call 'span_lookup_table' inside a generative qfunc"
-        )
-
-    return qnum_values(size, is_signed, fraction_digits)
-
-
-def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
-    """
-    Applies a classical function to quantum numbers.
-
-    Works by reducing the function into a lookup table over all the possible values
-    of the quantum numbers.
-
-    Args:
-        func: A Python function
-        *targets: One or more initialized quantum numbers
-
-    Returns:
-        The quantum result of applying func to targets
-
-    Notes:
-        Must be called inside a generative function (`@qfunc`)
-    """
-    if len(targets) == 0:
-        raise ClassiqValueError("No targets specified")
-
-    target_vals = [_get_qnum_values(target) for target in targets]
-    lookup_table = [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
-
-    index_size = sum(target.size for target in targets)
-    index: QNum = QNum(get_temp_var_name(), size=index_size)
-    result: QNum = QNum(get_temp_var_name("result"))
-
-    within_apply(
-        lambda: bind(list(targets), index),
-        lambda: assign(subscript(lookup_table, index), result),
-    )
-    return result

classiq/qmod/builtins/functions/qsvm.py

@@ -1,24 +0,0 @@
-from typing import Literal
-
-from classiq.qmod.builtins.structs import (
-    QSVMFeatureMapPauli,
-)
-from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CInt
-from classiq.qmod.qmod_variable import QArray, QBit
-
-
-@qfunc(external=True)
-def pauli_feature_map(
-    feature_map: QSVMFeatureMapPauli,
-    qbv: QArray[QBit, Literal["feature_map.feature_dimension"]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def bloch_sphere_feature_map(
-    feature_dimension: CInt,
-    qbv: QArray[QBit, Literal["ceiling(feature_dimension / 2)"]],
-) -> None:
-    pass