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

jijmodeling/sampleset/measuring_time.py

@@ -1,59 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Optional
-
-from jijmodeling.exceptions import SerializeSampleSetError
-from jijmodeling.sampleset.solving_time import SolvingTime
-from jijmodeling.sampleset.system_time import SystemTime
-
-
-@dataclass
-class MeasuringTime:
-    """Schema for measuring time.
-
-    Attributes:
-        solve (Optional[SolvingTime], optional): Instance of SolvingTime. This means solver running time. Defaults to None.
-        system (Optional[SystemTime], optional): Instance of SystemTime. This means time about jijzept system. Defaults to None.
-        total (Optional[float], optional): Total time from submitting problem to obtaining solution. Defaults to None.
-    """
-
-    solve: Optional[SolvingTime] = None
-    system: Optional[SystemTime] = None
-    total: Optional[float] = None
-
-    def __post_init__(self):
-        if self.solve is None:
-            self.solve = SolvingTime()
-        if self.system is None:
-            self.system = SystemTime()
-
-    @classmethod
-    def from_serializable(cls, obj: Dict):
-        """To MeasuringTime object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of MeasuringTime.
-
-        Returns:
-            MeasuringTime: MeasuringTime obj.
-        """
-
-        for key in ["solve", "system", "total"]:
-            if key not in obj.keys():
-                raise SerializeSampleSetError(f'"obj" does not contain "{key}" key')
-
-        if obj["solve"] is None:
-            solving_time = None
-        else:
-            solving_time = SolvingTime.from_serializable(obj["solve"])
-
-        if obj["system"] is None:
-            system_time = None
-        else:
-            system_time = SystemTime.from_serializable(obj["system"])
-        return cls(
-            solve=solving_time,
-            system=system_time,
-            total=obj["total"],
-        )

jijmodeling/sampleset/record.py

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, List, Tuple, Union
-
-import numpy as np
-import pandas as pd
-
-from jijmodeling.exceptions import SerializeSampleSetError
-from jijmodeling.type_annotations import DenseSolution, SparseSolution
-
-
-@dataclass
-class Record:
-    """Represents the Schema for solutions obtained by a solver.
-
-    Attributes:
-        solution (Dict[str, Union[List[SparseSolution], List[DenseSolution]]]): Solution. A key is the label of a decision variable. There are two type in value:
-            - SparseSolution is tuple of length 3, where each element means (nonzero index, nonzero value, shape) for solution.
-            - DenseSolution is numpy.ndarray which dimension is shape of decision variable.
-        num_occurrences (List[int]): Number of occurrences for each sample.
-    """
-
-    solution: Dict[str, Union[List[SparseSolution], List[DenseSolution]]]
-    num_occurrences: List[int]
-
-    def __post_init__(self):
-        self._is_dense = False
-        self._current_index = 0
-
-    def __len__(self) -> int:
-        """
-        Perform the operation __len__.
-        """
-        return len(self.num_occurrences)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        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]
-    ) -> Record:
-        """Perform the operation __getitem__.
-
-        Args:
-            item (Union[int, slice, List[int], Tuple[int], np.ndarray]): Index of solution and num_occurrences.
-
-        Returns:
-            Record: Record object.
-        """
-
-        if isinstance(item, int):
-            start, stop, step = item, item + 1, None
-            solution = {
-                label: solution[start:stop:step]
-                for label, solution in self.solution.items()
-            }
-            return Record(
-                solution=solution,
-                num_occurrences=self.num_occurrences[start:stop:step],
-            )
-        elif isinstance(item, slice):
-            start, stop, step = item.start, item.stop, item.step
-            solution = {
-                label: solution[start:stop:step]
-                for label, solution in self.solution.items()
-            }
-            return Record(
-                solution=solution,
-                num_occurrences=self.num_occurrences[start:stop:step],
-            )
-        elif isinstance(item, (list, tuple, np.ndarray)):
-            item = np.array(item) if len(item) else np.array([], dtype=int)
-            if item.dtype == int or item.dtype == bool:
-                index = np.arange(len(item))[item] if item.dtype == bool else item
-                solution = {
-                    label: [solution[i] for i in index]
-                    for label, solution in self.solution.items()
-                }
-                num_occurrences = np.array(self.num_occurrences)[item].tolist()
-                return Record(solution=solution, num_occurrences=num_occurrences)
-            else:
-                raise IndexError(f'Element of "{item}" must be int or bool.')
-        else:
-            raise IndexError(
-                f'Type of index "{item}" must be one of int or slice or List[int] or Tuple[int] or 1d numpy.ndarray.'
-            )
-
-    @property
-    def is_dense(self) -> bool:
-        """SparseSolution or DenseSolution:
-            - If True, DenseSolution,
-            - Else, SparseSolution.
-
-        Returns:
-            bool: True or False.
-        """
-        return self._is_dense
-
-    @is_dense.setter
-    def is_dense(self, b: bool):
-        self._is_dense = b
-
-    @classmethod
-    def from_serializable(cls, obj: Dict):
-        """To Record object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of Record.
-
-        Returns:
-            Record: Record obj.
-        """
-
-        for key in ["solution", "num_occurrences"]:
-            if key not in obj.keys():
-                raise SerializeSampleSetError(f'"obj" does not contain "{key}" key')
-        return cls(**obj)
-
-    def to_pandas_dataframe(self) -> pd.DataFrame:
-        """Convert Record object to pandas.DataFrame object.
-
-        Returns:
-            pandas.DataFrame: pandas.DataFrame object.
-        """
-        solution = pd.DataFrame({f"solution[{k}]": v for k, v in self.solution.items()})
-        num_occurrences = pd.DataFrame({"num_occurrences": self.num_occurrences})
-        return pd.concat([solution, num_occurrences], axis=1)
-
-    def to_dense(self, inplace: bool = False):
-        solution = {}
-        for label, si in self.solution.items():
-            array_list = []
-            for nonzero_index, values, shape in si:
-                array = np.zeros(shape)
-                if array.ndim:
-                    array[nonzero_index] = values
-                else:
-                    array = np.array(values)
-                array_list.append(array)
-            solution[label] = array_list
-        if inplace:
-            self.solution = solution
-            self._solution_type = DenseSolution
-        return Record(solution=solution, num_occurrences=self.num_occurrences)
-
-    def _extend(self, other):
-        for var_label, solution in other.solution.items():
-            self.solution[var_label].extend(solution)
-        self.num_occurrences.extend(other.num_occurrences)

jijmodeling/sampleset/sampleset.py

@@ -1,379 +0,0 @@
-from __future__ import annotations
-
-import datetime as dt
-
-import orjson
-
-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.
-        """
-        def default(obj):
-            if isinstance(obj, np.ndarray):
-                return obj.tolist()
-            else:
-                return obj
-
-        evaluation_to_serializable_obj = self.evaluation.to_serializable()
-        to_serializable_obj = asdict(self)
-        to_serializable_obj["evaluation"] = evaluation_to_serializable_obj
-        json_metadata = orjson.dumps( 
-            self.metadata, 
-            default = default,
-            option = orjson.OPT_SERIALIZE_NUMPY,
-        )
-        to_serializable_obj["metadata"] = orjson.loads(json_metadata)
-        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)