jijmodeling 0.13.1__cp39-cp39-win_amd64.whl → 1.11.0__cp39-cp39-win_amd64.whl

jijmodeling/sampleset/__init__.py

@@ -1,33 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.sampleset.evaluation as evaluation
-import jijmodeling.sampleset.measuring_time as measuring_time
-import jijmodeling.sampleset.record as record
-import jijmodeling.sampleset.sampleset as sampleset
-import jijmodeling.sampleset.solving_time as solving_time
-import jijmodeling.sampleset.system_time as system_time
-
-from jijmodeling.sampleset.evaluation import Evaluation
-from jijmodeling.sampleset.measuring_time import MeasuringTime
-from jijmodeling.sampleset.record import Record
-from jijmodeling.sampleset.sampleset import SampleSet, concatenate
-from jijmodeling.sampleset.solving_time import SolvingTime
-from jijmodeling.sampleset.system_time import SystemTime
-
-__all__ = [
-    "evaluation",
-    "measuring_time",
-    "record",
-    "sampleset",
-    "solving_time",
-    "system_time",
-    "SampleSet",
-    "Record",
-    "Evaluation",
-    "MeasuringTime",
-    "SolvingTime",
-    "SystemTime",
-    "concatenate",
-]

jijmodeling/sampleset/evaluation.py

@@ -1,289 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Dict, List, Optional, Tuple, Union
-
-import numpy as np
-import pandas as pd
-
-from jijmodeling.type_annotations import (
-    ConstraintExpressionValuesType,
-    ForallIndexType,
-    ForallValuesType,
-)
-
-
-@dataclass
-class Evaluation:
-    """Schema for results of evaluating solutions.
-
-    Attributes:
-        energy (List[float]): a list of values of energy.
-        objective (Optional[List[float]], optional): a list of values of objective function. Defaults to None.
-        constraint_violations (Optional[Dict[str, List[float]]], optional): a list of constraint violations. A key is the name of a constraint. A value is cost of a constraint. Defaults to None.
-        constraint_forall (Optional[ForallIndexType], optional): a list of indices of forall constraints. Defaults to None.
-        constraint_values (Optional[List[ForallValuesType]], optional): a list of values of forall constraints. Defaults to None.
-        penalty (Optional[Dict[str, List[float]]], optional): a list of costs of penalty terms. A key is the name of a penalty. A value is cost of a penalty term. Defaults to None.
-    """
-
-    energy: Optional[List[float]] = None
-    objective: Optional[List[float]] = None
-    constraint_violations: Optional[Dict[str, List[float]]] = None
-    constraint_forall: Optional[ForallIndexType] = field(default=None, repr=False)
-    constraint_values: Optional[List[ForallValuesType]] = field(
-        default=None, repr=False
-    )
-    penalty: Optional[Dict[str, List[float]]] = None
-
-    def __post_init__(self):
-        self._current_index = 0
-
-    def __len__(self) -> int:
-        """
-        Perform the operation __len__.
-        """
-        if self.energy is None:
-            return 0
-        else:
-            return len(self.energy)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        if self.energy is None:
-            raise StopIteration()
-        else:
-            if self._current_index == len(self.energy):
-                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]
-    ) -> Evaluation:
-        """Perform the operation __getitem__.
-
-        Args:
-            item (Union[int, slice, List[int], Tuple[int], np.ndarray]): Index of evaluation metrics.
-
-        Returns:
-            Evaluation: Evaluation object.
-        """
-
-        def _slice(start: int, stop: int, step: Optional[int] = None) -> Evaluation:
-            energy = None if self.energy is None else self.energy[start:stop:step]
-            objective = (
-                None if self.objective is None else self.objective[start:stop:step]
-            )
-            constraint_violations = (
-                None
-                if self.constraint_violations is None
-                else {
-                    label: constraint_violations[start:stop:step]
-                    for label, constraint_violations in self.constraint_violations.items()
-                }
-            )
-            constraint_values = (
-                None
-                if self.constraint_values is None
-                else self.constraint_values[start:stop:step]
-            )
-            penalty = (
-                None
-                if self.penalty is None
-                else {
-                    label: penalty[start:stop:step]
-                    for label, penalty in self.penalty.items()
-                }
-            )
-
-            return Evaluation(
-                energy=energy,
-                objective=objective,
-                constraint_violations=constraint_violations,
-                constraint_forall=self.constraint_forall,
-                constraint_values=constraint_values,
-                penalty=penalty,
-            )
-
-        if isinstance(item, int):
-            start, stop, step = item, item + 1, None
-            return _slice(start, stop, step)
-        elif isinstance(item, slice):
-            start, stop, step = item.start, item.stop, item.step
-            return _slice(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:
-                energy = (
-                    None
-                    if self.energy is None
-                    else np.array(self.energy)[item].tolist()
-                )
-                objective = (
-                    None
-                    if self.objective is None
-                    else np.array(self.objective)[item].tolist()
-                )
-                constraint_violations = (
-                    None
-                    if self.constraint_violations is None
-                    else {
-                        label: np.array(constraint_violations)[item].tolist()
-                        for label, constraint_violations in self.constraint_violations.items()
-                    }
-                )
-                constraint_values = (
-                    None
-                    if self.constraint_values is None
-                    else np.array(self.constraint_values)[item].tolist()
-                )
-                penalty = (
-                    None
-                    if self.penalty is None
-                    else {
-                        label: np.array(penalty)[item].tolist()
-                        for label, penalty in self.penalty.items()
-                    }
-                )
-                return Evaluation(
-                    energy=energy,
-                    objective=objective,
-                    constraint_violations=constraint_violations,
-                    constraint_forall=self.constraint_forall,
-                    constraint_values=constraint_values,
-                    penalty=penalty,
-                )
-            else:
-                raise IndexError(f'Element of "{item}" must be int or bool.')
-        else:
-            raise IndexError(
-                f'Type of index "{item}" must be int, slice, list[int], tuple[int, ...] or 1d numpy.ndarray.'
-            )
-
-    @property
-    def constraint_expr_values(self) -> List[ConstraintExpressionValuesType] | None:
-        """
-        Values for each constraint. The values are stored in `Dict[Tuple[int, ...], float]` for each condition expanded by `forall`.
-        """
-        if self.constraint_forall is None:
-            return None
-        if self.constraint_values is None:
-            return None
-
-        expr_values = []
-        for v in self.constraint_values:
-            expr_values.append(
-                {
-                    const_name: {
-                        tuple(i): vi
-                        for i, vi in zip(
-                            self.constraint_forall[const_name], v[const_name]
-                        )
-                    }
-                    for const_name in self.constraint_forall
-                }
-            )
-        return expr_values
-
-    def to_pandas_dataframe(self) -> pd.DataFrame:
-        """Convert Evaluation object to pandas.DataFrame object.
-
-        Returns:
-            pandas.DataFrame: pandas.DataFrame object.
-        """
-
-        evaluation = asdict(self)
-
-        if evaluation["constraint_violations"]:
-            constraint_violations = {
-                f"constraint_violation[{k}]": v
-                for k, v in evaluation.pop("constraint_violations").items()
-            }
-        else:
-            constraint_violations = {}
-            del evaluation["constraint_violations"]
-        evaluation.update(constraint_violations)
-        evaluation["constraint_forall"] = [self.constraint_forall] * len(self)
-
-        if self.penalty:
-            penalty = {f"penalty[{k}]": v for k, v in evaluation.pop("penalty").items()}
-        else:
-            penalty = {}
-            del evaluation["penalty"]
-        evaluation.update(penalty)
-
-        return pd.DataFrame(evaluation)
-
-    @classmethod
-    def from_serializable(cls, obj: dict):
-        """To Evaluation object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of Evaluation.
-
-        Returns:
-            Evaluation: Evaluation obj.
-        """
-
-        return cls(
-            energy=obj.get("energy"),
-            objective=obj.get("objective"),
-            constraint_violations=obj.get("constraint_violations"),
-            constraint_forall=obj.get("constraint_forall"),
-            constraint_values=obj.get("constraint_values"),
-            penalty=obj.get("penalty"),
-        )
-
-    def to_serializable(self):
-        return asdict(self)
-
-    def _extend(self, other: Evaluation):
-        if isinstance(other.energy, list):
-            # Concatenate energy
-            if self.energy is None:
-                self.energy = other.energy
-            else:
-                self.energy.extend(other.energy)
-
-        # Concatenate objective
-        if isinstance(other.objective, list):
-            if self.objective is None:
-                self.objective = other.objective
-            else:
-                self.objective.extend(other.objective)
-
-        # Concatenate constraint_violations
-        if isinstance(other.constraint_violations, dict):
-            if self.constraint_violations is None:
-                self.constraint_violations = other.constraint_violations
-            else:
-                for (
-                    con_label,
-                    constraint_violation,
-                ) in other.constraint_violations.items():
-                    self.constraint_violations[con_label].extend(constraint_violation)
-
-        # Overwrite constraint_forall
-        # Since SampleSet assumes that it does not contain solutions for different problem or instance data,
-        # the index of forall constraints (constraint_forall) are the same between the original SampleSet(self)
-        # and combined SampleSet(other)."
-        if isinstance(other.constraint_forall, dict):
-            self.constraint_forall = other.constraint_forall
-
-        if isinstance(other.constraint_values, list):
-            if self.constraint_values is None:
-                self.constraint_values = other.constraint_values
-            else:
-                self.constraint_values.extend(other.constraint_values)
-
-        # Concatenate penalty
-        if isinstance(other.penalty, dict):
-            if self.penalty is None:
-                self.penalty = other.penalty
-            else:
-                for pane_label, pena in other.penalty.items():
-                    self.penalty[pane_label].extend(pena)

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 or 0)
-                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)