job-shop-lib 0.5.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

job_shop_lib/dispatching/_unscheduled_operations_observer.py

@@ -0,0 +1,69 @@
+"""Home of the `UnscheduledOperationsObserver` class."""
+
+import collections
+from collections.abc import Iterable
+import itertools
+from typing import Deque
+
+from job_shop_lib import Operation, ScheduledOperation
+from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
+
+
+class UnscheduledOperationsObserver(DispatcherObserver):
+    """Stores the operations that have not been dispatched yet.
+
+    This observer maintains a list of deques, each containing unscheduled
+    operations for a specific job. It provides methods to access and
+    manipulate unscheduled operations efficiently.
+    """
+
+    def __init__(self, dispatcher: Dispatcher, *, subscribe: bool = True):
+        super().__init__(dispatcher, subscribe=subscribe)
+        self.unscheduled_operations_per_job: list[Deque[Operation]] = []
+        self.reset()
+        # In case the dispatcher has already scheduled some operations,
+        # we need to remove them.
+        # Note that we don't need to remove the operations in order.
+        for scheduled_operation in itertools.chain(
+            *self.dispatcher.schedule.schedule
+        ):
+            self.update(scheduled_operation)
+
+    @property
+    def unscheduled_operations(self) -> Iterable[Operation]:
+        """An iterable of all unscheduled operations across all jobs."""
+        return itertools.chain(*self.unscheduled_operations_per_job)
+
+    @property
+    def num_unscheduled_operations(self) -> int:
+        """The total number of unscheduled operations."""
+        total_operations = self.dispatcher.instance.num_operations
+        num_scheduled_operations = (
+            self.dispatcher.schedule.num_scheduled_operations
+        )
+        return total_operations - num_scheduled_operations
+
+    def update(self, scheduled_operation: ScheduledOperation) -> None:
+        """Removes a scheduled operation from the unscheduled operations.
+
+        This method is called by the dispatcher when an operation is
+        scheduled. It removes the operation from its job's deque of
+        unscheduled operations.
+
+        Args:
+            scheduled_operation: The operation that has been scheduled.
+        """
+        job_id = scheduled_operation.operation.job_id
+        job_deque = self.unscheduled_operations_per_job[job_id]
+        if job_deque:
+            job_deque.popleft()
+
+    def reset(self) -> None:
+        """Resets unscheduled operations to include all operations.
+
+        This method reinitializes the list of deques with all operations
+        from all jobs in the instance.
+        """
+        self.unscheduled_operations_per_job = [
+            collections.deque(job) for job in self.dispatcher.instance.jobs
+        ]

job_shop_lib/dispatching/feature_observers/__init__.py

@@ -1,16 +1,21 @@
 """Contains FeatureObserver classes for observing features of the
 dispatcher."""
 
-from .feature_observer import FeatureObserver, FeatureType
-from .composite_feature_observer import CompositeFeatureObserver
-from .earliest_start_time_observer import EarliestStartTimeObserver
-from .is_ready_observer import IsReadyObserver
-from .duration_observer import DurationObserver
-from .is_scheduled_observer import IsScheduledObserver
-from .position_in_job_observer import PositionInJobObserver
-from .remaining_operations_observer import RemainingOperationsObserver
-from .is_completed_observer import IsCompletedObserver
-from .factory import FeatureObserverType, feature_observer_factory
+from ._feature_observer import FeatureObserver, FeatureType
+from ._earliest_start_time_observer import EarliestStartTimeObserver
+from ._is_ready_observer import IsReadyObserver
+from ._duration_observer import DurationObserver
+from ._is_scheduled_observer import IsScheduledObserver
+from ._position_in_job_observer import PositionInJobObserver
+from ._remaining_operations_observer import RemainingOperationsObserver
+from ._is_completed_observer import IsCompletedObserver
+from ._factory import (
+    FeatureObserverType,
+    feature_observer_factory,
+    FeatureObserverConfig,
+)
+from ._composite_feature_observer import CompositeFeatureObserver
+
 
 __all__ = [
     "FeatureObserver",
@@ -25,4 +30,5 @@ __all__ = [
     "IsCompletedObserver",
     "FeatureObserverType",
     "feature_observer_factory",
+    "FeatureObserverConfig",
 ]

job_shop_lib/dispatching/feature_observers/{composite_feature_observer.py → _composite_feature_observer.py}

@@ -1,13 +1,24 @@
 """Home of the `CompositeFeatureObserver` class."""
 
 from collections import defaultdict
+from collections.abc import Sequence
+
+# The Self type can be imported directly from Python’s typing module in
+# version 3.11 and beyond. We use the typing_extensions module to support
+# python 3.10.
+from typing_extensions import Self
+
 import numpy as np
+from numpy.typing import NDArray
 import pandas as pd
 
+from job_shop_lib.exceptions import ValidationError
 from job_shop_lib.dispatching import Dispatcher
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
+    FeatureObserverConfig,
+    feature_observer_factory,
 )
 
 
@@ -29,8 +40,10 @@ class CompositeFeatureObserver(FeatureObserver):
     def __init__(
         self,
         dispatcher: Dispatcher,
-        feature_observers: list[FeatureObserver] | None = None,
+        *,
         subscribe: bool = True,
+        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_observers: list[FeatureObserver] | None = None,
     ):
         if feature_observers is None:
             feature_observers = [
@@ -38,11 +51,48 @@ class CompositeFeatureObserver(FeatureObserver):
                 for observer in dispatcher.subscribers
                 if isinstance(observer, FeatureObserver)
             ]
+        feature_types = self._get_feature_types_list(feature_types)
+        for observer in feature_observers:
+            if not set(observer.features.keys()).issubset(set(feature_types)):
+                raise ValidationError(
+                    "The feature types observed by the feature observer "
+                    f"{observer.__class__.__name__} are not a subset of the "
+                    "feature types specified in the CompositeFeatureObserver."
+                    f"Observer feature types: {observer.features.keys()}"
+                    f"Composite feature types: {feature_types}"
+                )
         self.feature_observers = feature_observers
         self.column_names: dict[FeatureType, list[str]] = defaultdict(list)
         super().__init__(dispatcher, subscribe=subscribe)
         self._set_column_names()
 
+    @classmethod
+    def from_feature_observer_configs(
+        cls,
+        dispatcher: Dispatcher,
+        feature_observer_configs: Sequence[FeatureObserverConfig],
+        subscribe: bool = True,
+    ) -> Self:
+        """Creates the composite feature observer.
+
+        Args:
+            dispatcher:
+                The dispatcher used to create the feature observers.
+            feature_observer_configs:
+                The list of feature observer configuration objects.
+            subscribe:
+                Whether to subscribe the CompositeFeatureObserver to the
+                dispatcher.
+        """
+        observers = [
+            feature_observer_factory(observer_config, dispatcher=dispatcher)
+            for observer_config in feature_observer_configs
+        ]
+        composite_observer = cls(
+            dispatcher, feature_observers=observers, subscribe=subscribe
+        )
+        return composite_observer
+
     @property
     def features_as_dataframe(self) -> dict[FeatureType, pd.DataFrame]:
         """Returns the features as a dictionary of `pd.DataFrame` instances."""
@@ -54,7 +104,9 @@ class CompositeFeatureObserver(FeatureObserver):
         }
 
     def initialize_features(self):
-        features: dict[FeatureType, list[np.ndarray]] = defaultdict(list)
+        features: dict[FeatureType, list[NDArray[np.float32]]] = defaultdict(
+            list
+        )
         for observer in self.feature_observers:
             for feature_type, feature_matrix in observer.features.items():
                 features[feature_type].append(feature_matrix)
@@ -85,3 +137,33 @@ class CompositeFeatureObserver(FeatureObserver):
             out.append(f"{feature_type.value}:")
             out.append(dataframe.to_string())
         return "\n".join(out)
+
+
+if __name__ == "__main__":
+    from cProfile import Profile
+    from job_shop_lib.benchmarking import load_benchmark_instance
+    from job_shop_lib.dispatching.rules import DispatchingRuleSolver
+    from job_shop_lib.dispatching.feature_observers import (
+        FeatureObserverType,
+    )
+
+    ta80 = load_benchmark_instance("ta80")
+
+    dispatcher_ = Dispatcher(ta80)
+    feature_observer_types_ = list(FeatureObserverType)
+    feature_observers_ = [
+        feature_observer_factory(
+            observer_type,
+            dispatcher=dispatcher_,
+        )
+        for observer_type in feature_observer_types_
+        if not observer_type == FeatureObserverType.COMPOSITE
+        # and not FeatureObserverType.EARLIEST_START_TIME
+    ]
+    composite_observer_ = CompositeFeatureObserver(
+        dispatcher_, feature_observers=feature_observers_
+    )
+    solver = DispatchingRuleSolver(dispatching_rule="random")
+    profiler = Profile()
+    profiler.runcall(solver.solve, dispatcher_.instance, dispatcher_)
+    profiler.print_stats("cumtime")

job_shop_lib/dispatching/feature_observers/{duration_observer.py → _duration_observer.py}

@@ -2,7 +2,6 @@
 
 import numpy as np
 
-from job_shop_lib.dispatching import Dispatcher
 from job_shop_lib import ScheduledOperation
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
@@ -13,30 +12,20 @@ from job_shop_lib.dispatching.feature_observers import (
 class DurationObserver(FeatureObserver):
     """Measures the remaining duration of operations, machines, and jobs.
 
-    The duration of an Operation is:
+    The duration of an :class:`Operation` is:
         - if the operation has not been scheduled, it is the duration of the
-        operation.
+          operation.
         - if the operation has been scheduled, it is the remaining duration of
-        the operation.
+          the operation.
         - if the operation has been completed, it is the last duration of the
-        operation that has been computed. The duration must be set to 0
-        manually if needed. We do not update the duration of completed
-        operations to save computation time.
+          operation that has been computed. The duration must be set to 0
+          manually if needed. We do not update the duration of completed
+          operations to save computation time.
 
     The duration of a Machine or Job is the sum of the durations of the
     unscheduled operations that belong to the machine or job.
     """
 
-    def __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        subscribe: bool = True,
-    ):
-        super().__init__(
-            dispatcher, feature_types, feature_size=1, subscribe=subscribe
-        )
-
     def initialize_features(self):
         mapping = {
             FeatureType.OPERATIONS: self._initialize_operation_durations,

job_shop_lib/dispatching/feature_observers/{earliest_start_time_observer.py → _earliest_start_time_observer.py}

@@ -7,18 +7,26 @@ from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
 )
-from job_shop_lib.scheduled_operation import ScheduledOperation
+from job_shop_lib import ScheduledOperation
 
 
 class EarliestStartTimeObserver(FeatureObserver):
     """Observer that adds a feature indicating the earliest start time of
     each operation, machine, and job in the graph."""
 
+    __slots__ = (
+        "earliest_start_times",
+        "_job_ids",
+        "_positions",
+        "machine_ids",
+    )
+
     def __init__(
         self,
         dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        *,
         subscribe: bool = True,
+        feature_types: list[FeatureType] | FeatureType | None = None,
     ):
 
         # Earliest start times initialization
@@ -32,8 +40,32 @@ class EarliestStartTimeObserver(FeatureObserver):
         )
         self.earliest_start_times[np.isnan(squared_duration_matrix)] = np.nan
         # -------------------------------
+
+        # Cache:
+        operations_by_machine = dispatcher.instance.operations_by_machine
+        self._is_regular_instance = all(
+            len(job) == len(dispatcher.instance.jobs[0])
+            for job in dispatcher.instance.jobs
+        )
+        if self._is_regular_instance:
+            self._job_ids = np.array(
+                [
+                    [op.job_id for op in machine_ops]
+                    for machine_ops in operations_by_machine
+                ]
+            )
+            self._positions = np.array(
+                [
+                    [op.position_in_job for op in machine_ops]
+                    for machine_ops in operations_by_machine
+                ]
+            )
+        else:
+            self._job_ids = np.array([])
+            self._positions = np.array([])
+
         super().__init__(
-            dispatcher, feature_types, feature_size=1, subscribe=subscribe
+            dispatcher, feature_types=feature_types, subscribe=subscribe
         )
 
     def update(self, scheduled_operation: ScheduledOperation):
@@ -68,31 +100,56 @@ class EarliestStartTimeObserver(FeatureObserver):
 
         # Now, we compute the gap that could be introduced by the new
         # next_available_time of the machine.
-        operations_by_machine = self.dispatcher.instance.operations_by_machine
-        for operation in operations_by_machine[scheduled_operation.machine_id]:
-            if self.dispatcher.is_scheduled(operation):
-                continue
-            old_start_time = self.earliest_start_times[
-                operation.job_id, operation.position_in_job
-            ]
-            new_start_time = max(old_start_time, scheduled_operation.end_time)
-            gap = new_start_time - old_start_time
-            self.earliest_start_times[
-                operation.job_id, operation.position_in_job :
-            ] += gap
+        machine_ops = self.dispatcher.instance.operations_by_machine[
+            scheduled_operation.machine_id
+        ]
+        unscheduled_mask = np.array(
+            [not self.dispatcher.is_scheduled(op) for op in machine_ops]
+        )
+        if np.any(unscheduled_mask):
+            if self._job_ids.size == 0:
+                job_ids = np.array([op.job_id for op in machine_ops])[
+                    unscheduled_mask
+                ]
+            else:
+                job_ids = self._job_ids[scheduled_operation.machine_id][
+                    unscheduled_mask
+                ]
+
+            if self._positions.size == 0:
+                positions = np.array(
+                    [op.position_in_job for op in machine_ops]
+                )[unscheduled_mask]
+            else:
+                positions = self._positions[scheduled_operation.machine_id][
+                    unscheduled_mask
+                ]
+            old_start_times = self.earliest_start_times[job_ids, positions]
+            new_start_times = np.maximum(
+                scheduled_operation.end_time, old_start_times
+            )
+            gaps = new_start_times - old_start_times
+
+            for job_id, position, gap in zip(job_ids, positions, gaps):
+                self.earliest_start_times[job_id, position:] += gap
 
         self.initialize_features()
 
     def initialize_features(self):
         """Initializes the features based on the current state of the
         dispatcher."""
-        mapping = {
-            FeatureType.OPERATIONS: self._update_operation_features,
-            FeatureType.MACHINES: self._update_machine_features,
-            FeatureType.JOBS: self._update_job_features,
-        }
         for feature_type in self.features:
-            mapping[feature_type]()
+            if feature_type == FeatureType.OPERATIONS:
+                self._update_operation_features()
+            elif (
+                feature_type == FeatureType.MACHINES
+                and self._is_regular_instance
+            ):
+                self._update_machine_features_vectorized()
+            elif feature_type == FeatureType.MACHINES:
+                self._update_machine_features()
+            elif feature_type == FeatureType.JOBS:
+                self._update_job_features()
 
     def _update_operation_features(self):
         """Ravels the 2D array into a 1D array"""
@@ -127,6 +184,42 @@ class EarliestStartTimeObserver(FeatureObserver):
                 min_earliest_start_time - current_time
             )
 
+    def _update_machine_features_vectorized(self):
+        """Picks the minimum start time of all operations that can be scheduled
+        on that machine"""
+        current_time = self.dispatcher.current_time()
+        operations_by_machine = self.dispatcher.instance.operations_by_machine
+
+        # Create a mask for unscheduled operations
+        is_unscheduled = np.array(
+            [
+                [not self.dispatcher.is_scheduled(op) for op in machine_ops]
+                for machine_ops in operations_by_machine
+            ]
+        )
+
+        # Get earliest start times for all operations
+        earliest_start_times = self.earliest_start_times[
+            self._job_ids, self._positions
+        ]
+
+        # Apply mask for unscheduled operations
+        masked_start_times = np.where(
+            is_unscheduled, earliest_start_times, np.inf
+        )
+
+        # Find minimum start time for each machine
+        min_start_times = np.min(masked_start_times, axis=1)
+
+        # Handle cases where all operations are scheduled
+        min_start_times = np.where(
+            np.isinf(min_start_times), 0, min_start_times
+        )
+
+        self.features[FeatureType.MACHINES][:, 0] = (
+            min_start_times - current_time
+        )
+
     def _update_job_features(self):
         """Picks the earliest start time of the next operation in the job"""
         current_time = self.dispatcher.current_time()
@@ -140,17 +233,3 @@ class EarliestStartTimeObserver(FeatureObserver):
                 self.earliest_start_times[job_id, next_operation_idx]
                 - current_time
             )
-
-
-if __name__ == "__main__":
-    squared_durations_matrix = np.array([[1, 1, 7], [5, 1, 1], [1, 3, 2]])
-    # Add a zeros column to the left of the matrix
-    cumulative_durations = np.hstack(
-        (
-            np.zeros((squared_durations_matrix.shape[0], 1)),
-            squared_durations_matrix[:, :-1],
-        )
-    )
-    # Set to nan the values that are not available
-    cumulative_durations[np.isnan(squared_durations_matrix)] = np.nan
-    print(cumulative_durations)

job_shop_lib/dispatching/feature_observers/{factory.py → _factory.py}

@@ -2,6 +2,7 @@
 
 from enum import Enum
 
+from job_shop_lib.dispatching import DispatcherObserverConfig
 from job_shop_lib.dispatching.feature_observers import (
     IsReadyObserver,
     EarliestStartTimeObserver,
@@ -15,8 +16,7 @@ from job_shop_lib.dispatching.feature_observers import (
 
 
 class FeatureObserverType(str, Enum):
-    """Enumeration of node feature creator types for the job shop scheduling
-    problem."""
+    """Enumeration of the different feature observers."""
 
     IS_READY = "is_ready"
     EARLIEST_START_TIME = "earliest_start_time"
@@ -28,15 +28,30 @@ class FeatureObserverType(str, Enum):
     COMPOSITE = "composite"
 
 
+# FeatureObserverConfig = DispatcherObserverConfig[
+#     type[FeatureObserver] | FeatureObserverType | str
+# ]
+FeatureObserverConfig = (
+    DispatcherObserverConfig[type[FeatureObserver]]
+    | DispatcherObserverConfig[FeatureObserverType]
+    | DispatcherObserverConfig[str]
+)
+
+
 def feature_observer_factory(
-    node_feature_creator_type: str | FeatureObserverType,
+    feature_creator_type: (
+        str
+        | FeatureObserverType
+        | type[FeatureObserver]
+        | FeatureObserverConfig
+    ),
     **kwargs,
 ) -> FeatureObserver:
     """Creates and returns a node feature creator based on the specified
     node feature creator type.
 
     Args:
-        node_feature_creator_type:
+        feature_creator_type:
             The type of node feature creator to create.
         **kwargs:
             Additional keyword arguments to pass to the node
@@ -45,6 +60,17 @@ def feature_observer_factory(
     Returns:
         A node feature creator instance.
     """
+    if isinstance(feature_creator_type, DispatcherObserverConfig):
+        return feature_observer_factory(
+            feature_creator_type.class_type,
+            **feature_creator_type.kwargs,
+            **kwargs,
+        )
+    # if the instance is of type type[FeatureObserver] we can just
+    # call the object constructor with the keyword arguments
+    if isinstance(feature_creator_type, type):
+        return feature_creator_type(**kwargs)
+
     mapping: dict[FeatureObserverType, type[FeatureObserver]] = {
         FeatureObserverType.IS_READY: IsReadyObserver,
         FeatureObserverType.EARLIEST_START_TIME: EarliestStartTimeObserver,
@@ -54,5 +80,5 @@ def feature_observer_factory(
         FeatureObserverType.REMAINING_OPERATIONS: RemainingOperationsObserver,
         FeatureObserverType.IS_COMPLETED: IsCompletedObserver,
     }
-    feature_creator = mapping[node_feature_creator_type]  # type: ignore[index]
+    feature_creator = mapping[feature_creator_type]  # type: ignore[index]
     return feature_creator(**kwargs)