jijmodeling 0.10.15__cp310-cp310-win_amd64.whl → 1.11.0__cp310-cp310-win_amd64.whl

jijmodeling/sampleset/sampleset.py

@@ -1,381 +0,0 @@
-from __future__ import annotations
-
-import datetime as dt
-import json
-
-from copy import deepcopy
-from dataclasses import asdict, dataclass
-from typing import Dict, List, Optional, Tuple, Union
-
-import numpy as np
-import pandas as pd
-
-from jijmodeling.exceptions import SampleSetNotEvaluatedError, SerializeSampleSetError
-from jijmodeling.sampleset.evaluation import Evaluation
-from jijmodeling.sampleset.measuring_time import MeasuringTime
-from jijmodeling.sampleset.record import Record
-
-
-@dataclass
-class SampleSet:
-    """Schema for sampleset.
-
-    Attributes:
-        record (Record): Record object. This means basic infomation of solutions.
-        evaluation (Evaluation): Evaluation object. This means evaluation results of solutions.
-        measuring_time (MeasuringTime): MeasuringTime object. This means measuring time of various processing until solutions is obtained.
-    """
-
-    record: Record
-    evaluation: Evaluation
-    measuring_time: MeasuringTime
-
-    def __post_init__(self):
-        self._is_dense = False
-        self._current_index = 0
-        self._metadata = {}
-
-    def __len__(self) -> int:
-        """
-        Perform the operation __len__.
-        """
-        return self.record.__len__()
-
-    def __iter__(self):
-        """
-        Perform the operation __iter__.
-        """
-        return self
-
-    def __next__(self):
-        """
-        Perform the operation __next__.
-        """
-        if self._current_index == len(self):
-            self._current_index = 0
-            raise StopIteration()
-        ret = self[self._current_index]
-        self._current_index += 1
-        return ret
-
-    def __getitem__(
-        self, item: Union[int, slice, List[int], Tuple[int], np.ndarray]
-    ) -> SampleSet:
-        """Perform the operation __getitem__.
-
-        Args:
-            item (Union[int, slice, List[int], Tuple[int], np.ndarray]): Index of sampleset.
-
-        Returns:
-            Record: SampleSet object.
-        """
-        record = self.record[item]
-        evaluation = self.evaluation[item]
-        return SampleSet(
-            record=record, evaluation=evaluation, measuring_time=self.measuring_time
-        )
-
-    @property
-    def is_dense(self) -> bool:
-        """SparseSolution or DenseSolution:
-            - If True, DenseSolution,
-            - Else, SparseSolution.
-
-        Returns:
-            bool: True or False.
-        """
-        return self._is_dense
-
-    @property
-    def metadata(self) -> Dict:
-        """Store information which is not in SampleSet schema.
-
-        Returns:
-            dict: Metadata.
-        """
-        return self._metadata
-
-    @is_dense.setter
-    def is_dense(self, b: bool):
-        self._is_dense = b
-
-    def to_pandas_dataframe(self) -> pd.DataFrame:
-        """Convert SampleSet object to pandas.DataFrame object.
-
-        Returns:
-            pandas.DataFrame: pandas.DataFrame object.
-        """
-        record = self.record.to_pandas_dataframe()
-        evaluation = self.evaluation.to_pandas_dataframe()
-
-        return pd.concat([record, evaluation], axis=1)
-
-    def to_dense(self, inplace: bool = False):
-        """Convert SparseSolution to DenseSolution.
-
-        Args:
-            inplace (bool, optional): Modify the SampleSet object in place (do not create a new object). Defaults to False.
-
-        Returns:
-            SampleSet or None: SampleSet with dense solution or None if inplace=True.
-        """
-        if self.is_dense:
-            if inplace:
-                return None
-            else:
-                return self
-        elif inplace:
-            self.record.to_dense(inplace=inplace)
-            self._is_dense = True
-            return None
-        else:
-            record = self.record.to_dense(inplace=inplace)
-            sampleset = SampleSet(
-                record=record,
-                evaluation=self.evaluation,
-                measuring_time=self.measuring_time,
-            )
-            sampleset.is_dense = True
-            return sampleset
-
-    @classmethod
-    def from_serializable(cls, obj: Dict):
-        """To SampleSet object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of SampleSet.
-
-        Returns:
-            SampleSet: SampleSet obj.
-        """
-        for key in ["record", "evaluation", "measuring_time"]:
-            if key not in obj.keys():
-                raise SerializeSampleSetError(f'"obj" does not contain "{key}" key')
-
-        if "metadata" in obj:
-            if isinstance(obj["metadata"], dict):
-                metadata = obj["metadata"]
-            else:
-                raise TypeError('Type of "metadata" must be dict')
-        else:
-            metadata = {}
-
-        solution = {}
-        for k, v in obj["record"]["solution"].items():
-            solution[k] = [(tuple(vi[0]), vi[1], tuple(vi[2])) for vi in v]
-        obj["record"]["solution"] = solution
-
-        record = Record.from_serializable(obj["record"])
-        evaluation = Evaluation.from_serializable(obj["evaluation"])
-        measuring_time = MeasuringTime.from_serializable(obj["measuring_time"])
-
-        sampleset = cls(
-            record=record,
-            evaluation=evaluation,
-            measuring_time=measuring_time,
-        )
-        sampleset.metadata.update(metadata)
-
-        return sampleset
-
-    def to_serializable(self) -> Dict:
-        """To Dict of SampleSet from SampleSet object.
-
-        Returns:
-            SampleSet: Dict of SampleSet.
-        """
-
-        class _NumpyEncoder(json.JSONEncoder):
-            def default(self, o):
-                if isinstance(o, np.integer):
-                    return int(o)
-                elif isinstance(o, np.floating):
-                    return float(o)
-                elif isinstance(o, np.ndarray):
-                    return o.tolist()
-                else:
-                    return super().default(o)
-
-        evaluation_to_serializable_obj = self.evaluation.to_serializable()
-        to_serializable_obj = asdict(self)
-        to_serializable_obj["evaluation"] = evaluation_to_serializable_obj
-        to_serializable_obj["metadata"] = json.loads(
-            json.dumps(self.metadata, cls=_NumpyEncoder)
-        )
-        return to_serializable_obj
-
-    def feasible(self):
-        """Return feasible solutions.
-
-        Returns:
-            SampleSet: Output only feasible solutions from self.record.solution.
-        """
-
-        if self.evaluation.constraint_violations is None:
-            raise SampleSetNotEvaluatedError("Your SampleSet object is not evaluated.")
-        else:
-            constraint_violations = np.array(
-                list(self.evaluation.constraint_violations.values())
-            )
-            if len(constraint_violations):
-                is_feas = constraint_violations.sum(axis=0) == 0
-                return SampleSet(
-                    record=self.record[is_feas],
-                    evaluation=self.evaluation[is_feas],
-                    measuring_time=self.measuring_time,
-                )
-            else:
-                return self
-
-    def infeasible(self):
-        """Return infeasible solutions.
-
-        Returns:
-            SampleSet: Output only feasible solutions from self.record.solution.
-        """
-        if self.evaluation.constraint_violations is None:
-            raise SampleSetNotEvaluatedError("Your SampleSet object is not evaluated.")
-        else:
-            constraint_violations = np.array(
-                list(self.evaluation.constraint_violations.values())
-            )
-            if len(constraint_violations):
-                is_infeas = constraint_violations.sum(axis=0) != 0
-                return SampleSet(
-                    record=self.record[is_infeas],
-                    evaluation=self.evaluation[is_infeas],
-                    measuring_time=self.measuring_time,
-                )
-            else:
-                return self[[]]
-
-    def lowest(self):
-        """Return solutions with lowest objective in feasible solutions.
-
-        Returns:
-            SampleSet: Output only lowest objecive solutions in feasibles from self.record.solution.
-        """
-
-        if self.evaluation.objective is None:
-            raise SampleSetNotEvaluatedError("Your SampleSet object is not evaluated.")
-        else:
-            feas = self.feasible()
-            objective = np.array(feas.evaluation.objective)
-            is_lowest = objective == objective.min() if len(objective) else []
-            return SampleSet(
-                record=feas.record[is_lowest],
-                evaluation=feas.evaluation[is_lowest],
-                measuring_time=feas.measuring_time,
-            )
-
-    def get_backend_calculation_time(self):
-        """You can check calculation time for each process in detail.
-
-        Returns:
-            Dict: Processed metadata for describing JijZept backends.
-        """
-
-        def _get_root_keys(obj: Dict):
-            if not isinstance(obj, dict):
-                raise TypeError(f"Type of 'obj' must be Dict, not {obj.__class__}.")
-
-            root_keys = []
-            for k, v in obj.items():
-                if isinstance(v, dict):
-                    parent_id = v.get("parent_id", "")
-                    if parent_id is None:
-                        root_keys.append(k)
-            return root_keys
-
-        def _timedelta(start: str, end: str):
-            s = dt.datetime.strptime(start, "%Y-%m-%dT%H:%M:%S.%fZ")
-            e = dt.datetime.strptime(end, "%Y-%m-%dT%H:%M:%S.%fZ")
-            return (e - s).total_seconds()
-
-        def _get_timedelata_by_span(obj: Dict, res: Optional[Dict] = None):
-            if res is None:
-                res = {}
-
-            for k, v in obj.items():
-                if isinstance(v, dict):
-                    if "start_time" in v:
-                        res[k] = {
-                            "time": _timedelta(v["start_time"], v["end_time"]),
-                            "span_id": v["context"]["span_id"],
-                            "parent_id": v["parent_id"],
-                        }
-                    else:
-                        res[k] = _get_timedelata_by_span(v, {})
-            return res
-
-        def _aggregate(obj: Dict, root_key: str, res: Optional[Dict] = None):
-            if res is None:
-                v = obj.pop(root_key, None)
-                if v is None:
-                    return {}
-                else:
-                    res = {
-                        root_key: {
-                            "id": v["span_id"],
-                            "time": v["time"],
-                        }
-                    }
-            for v_res in res.values():
-                time_map = {
-                    k: {"id": v["span_id"], "time": v["time"]}
-                    for k, v in obj.items()
-                    if v.get("parent_id", "") == v_res["id"]
-                }
-
-                if time_map:
-                    del v_res["id"], v_res["time"]
-                    v_res.update(_aggregate(obj, root_key, time_map))
-                else:
-                    del v_res["id"]
-            return res
-
-        def _reformat(obj: Dict):
-            for k, v in obj.items():
-                if isinstance(v, dict):
-                    if "time" in v:
-                        obj[k] = v["time"]
-                    else:
-                        obj[k] = _reformat(v)
-            return obj
-
-        root_keys = _get_root_keys(self.metadata)
-        time = {}
-        for root_key in root_keys:
-            metadata = _get_timedelata_by_span(self.metadata)
-            metadata = _aggregate(metadata, root_key)
-            metadata = _reformat(metadata)
-            time.update(metadata)
-        return time
-
-    def _extend(self, other):
-        self.record._extend(other.record)
-        self.evaluation._extend(other.evaluation)
-        # TODO: concatenates MeasuringTime objects
-
-
-def concatenate(
-    jm_sampleset_list: List[SampleSet],
-) -> SampleSet:
-    """
-    Concatenates SampleSet objects into a single SampleSet object.
-
-    Args:
-        jm_sampleset_list (List[SampleSet]): a list of SampleSet objects
-
-    Returns:
-        SampleSet: a SampleSet object that be concatenated
-    """
-    if len(jm_sampleset_list) == 0:
-        raise ValueError("empty list is invalid")
-    elif len(jm_sampleset_list) == 1:
-        return jm_sampleset_list[0]
-    else:
-        concat_sampleset = deepcopy(jm_sampleset_list[0])
-        for jm_sampleset in jm_sampleset_list[1:]:
-            concat_sampleset._extend(jm_sampleset)
-        return concat_sampleset

jijmodeling/sampleset/solving_time.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Optional
-
-from jijmodeling.exceptions import SerializeSampleSetError
-
-
-@dataclass
-class SolvingTime:
-    """Schema for solver running time.
-
-    Attributes:
-        preprocess (Optional[float], optional): Time to preprocess. Defaults to None.
-        solve (Optional[float], optional): Time to solve. Defaults to None.
-        postprocess (Optional[float], optional): Time to postprocess. Defaults to None.
-    """
-
-    preprocess: Optional[float] = None
-    solve: Optional[float] = None
-    postprocess: Optional[float] = None
-
-    @classmethod
-    def from_serializable(cls, obj: Dict):
-        """To SolvingTime object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of SolvingTime.
-
-        Returns:
-            SolvingTime: SolvingTime obj.
-        """
-
-        for key in ["preprocess", "solve", "postprocess"]:
-            if key not in obj.keys():
-                raise SerializeSampleSetError(f'"obj" does not contain "{key}" key')
-
-        return cls(**obj)

jijmodeling/sampleset/system_time.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Optional
-
-from jijmodeling.exceptions import SerializeSampleSetError
-
-
-@dataclass
-class SystemTime:
-    """Schema for system of jijzept running time.
-
-    Args:
-        post_problem_and_instance_data (Optional[float], optional): Time to upload problem and instance_data to blob. Defaults to None.
-        request_queue (Optional[float], optional): Time to send request to queue. Defaults to None.
-        fetch_problem_and_instance_data (Optional[float], optional): Time to fetch problme and instance_data from blob. Defaults to None.
-        fetch_result (Optional[float], optional): Time to fetch result. Defaults to None.
-        deserialize_solution (Optional[float], optional): Time to deserialize json object. Defaults to None.
-    """
-
-    post_problem_and_instance_data: Optional[float] = None
-    request_queue: Optional[float] = None
-    fetch_problem_and_instance_data: Optional[float] = None
-    fetch_result: Optional[float] = None
-    deserialize_solution: Optional[float] = None
-
-    @classmethod
-    def from_serializable(cls, obj: Dict):
-        """To SystemTime object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of SystemTime.
-
-        Returns:
-            SystemTime: SystemTime obj.
-        """
-
-        for key in [
-            "post_problem_and_instance_data",
-            "request_queue",
-            "fetch_problem_and_instance_data",
-            "fetch_result",
-            "deserialize_solution",
-        ]:
-            if key not in obj.keys():
-                raise SerializeSampleSetError(f'"obj" does not contain "{key}" key')
-
-        return cls(**obj)

jijmodeling/type_annotations/__init__.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.type_annotations.type_annotations as type_annotations
-
-from jijmodeling.type_annotations.type_annotations import (
-    DECI_VALUES_INTEREFACE,
-    DECISION_VALUES,
-    FIXED_VARIABLES,
-    FIXED_VARS_INTERFACE,
-    PH_VALUES_INTERFACE,
-    PLACEHOLDER_VALUES,
-    VARIABLE_KEY,
-    DenseSolution,
-    ListValue,
-    NumberValue,
-    SparseSolution,
-    TensorValue,
-)
-
-__all__ = [
-    "type_annotations",
-    "NumberValue",
-    "TensorValue",
-    "ListValue",
-    "VARIABLE_KEY",
-    "PH_VALUES_INTERFACE",
-    "PLACEHOLDER_VALUES",
-    "DECI_VALUES_INTEREFACE",
-    "DECISION_VALUES",
-    "FIXED_VARS_INTERFACE",
-    "FIXED_VARIABLES",
-    "SparseSolution",
-    "DenseSolution",
-]

jijmodeling/type_annotations/type_annotations.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-"""TYPE ANNOTATIONS.
-
-Describe the types related to the data needed to change from JijModeling to another type, such as to_pyqubo or calc_value.
-"""
-
-import typing as tp
-
-import numpy as np
-
-from jijmodeling.expression.variables.deci_vars import DecisionVariable
-from jijmodeling.expression.variables.placeholders import Placeholder
-
-NumberValue = tp.Union[int, float]
-TensorValue = tp.Union[NumberValue, np.ndarray]
-ListValue = tp.List[NumberValue]
-NonZeroIndices = tp.Tuple[tp.List[int], ...]
-NonZeroValues = tp.Union[tp.List[tp.Union[int, float]], tp.Union[int, float]]
-Shape = tp.Tuple[int, ...]
-SparseSolution = tp.Tuple[
-    NonZeroIndices,
-    NonZeroValues,
-    Shape,
-]
-DenseSolution = np.ndarray
-
-VARIABLE_KEY = tp.Union[str, Placeholder]
-# User interface for values of placeholder.
-PH_VALUES_INTERFACE = tp.Dict[VARIABLE_KEY, tp.Union[TensorValue, ListValue]]
-# type of value of placholders for inner handling.
-PLACEHOLDER_VALUES = tp.Dict[Placeholder, tp.Union[TensorValue, ListValue]]
-
-DECI_VALUES_INTEREFACE = tp.Dict[tp.Union[str, DecisionVariable], TensorValue]
-DECISION_VALUES = tp.Dict[DecisionVariable, TensorValue]
-
-# fixed variable
-# ex. fix array element : {"x": {(0, 1, 2): 1}} means x[0, 1, 2] = 1
-#     fix scalar variable: {"y": {(): 0}} means y = 0
-FIXED_VARS_INTERFACE = tp.Dict[
-    tp.Union[str, DecisionVariable],
-    tp.Dict[tp.Tuple[int, ...], NumberValue],
-]
-FIXED_VARIABLES = tp.Dict[DecisionVariable, tp.Dict[tp.Tuple[int, ...], NumberValue]]

jijmodeling/utils/__init__.py

@@ -1,28 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.utils.utils as utils
-
-from jijmodeling.utils.utils import (
-    FixedVariables,
-    SerializedFixedVariables,
-    deserialize_fixed_var,
-    serialize_fixed_var,
-    simple_dict_validation,
-    simple_list_validation,
-    validate_value,
-    with_measuring_time,
-)
-
-__all__ = [
-    "utils",
-    "validate_value",
-    "FixedVariables",
-    "SerializedFixedVariables",
-    "simple_list_validation",
-    "simple_dict_validation",
-    "with_measuring_time",
-    "serialize_fixed_var",
-    "deserialize_fixed_var",
-]