cejsp 0.4.1__py3-none-any.whl

cejsp/__init__.py

@@ -0,0 +1,19 @@
+"""CEJSP: JSP Complexity Estimator, with compatible model persistence."""
+from xai_complex import normalize_instance, summarize_instance, estimate_features
+from xai_complex import SolverTargetCalibrator, status_to_complexity, __version__
+from .io import load_instance
+from xai_complex.categories import CATEGORIES
+
+__all__ = ["normalize_instance", "summarize_instance", "estimate_features",
+           "SolverTargetCalibrator", "status_to_complexity", "ComplexityEstimator",
+           "JobShopComplexityClassifier", "load_instance", "CATEGORIES"]
+
+
+def __getattr__(name):
+    if name == "JobShopComplexityClassifier":
+        from .classifier import JobShopComplexityClassifier
+        return JobShopComplexityClassifier
+    if name == "ComplexityEstimator":
+        from xai_complex import ComplexityEstimator
+        return ComplexityEstimator
+    raise AttributeError(name)

cejsp/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

cejsp/batch.py

@@ -0,0 +1,3 @@
+from xai_complex.batch import estimate_features
+
+__all__ = ["estimate_features"]

cejsp/classifier.py

@@ -0,0 +1,4 @@
+from xai_complex.classifier import JobShopComplexityClassifier, train_manifest
+from xai_complex.categories import CATEGORIES
+
+__all__ = ["JobShopComplexityClassifier", "train_manifest", "CATEGORIES"]

cejsp/cli.py

@@ -0,0 +1,3 @@
+from xai_complex.cli import main
+
+__all__ = ["main"]

cejsp/estimator.py

@@ -0,0 +1,3 @@
+from xai_complex.estimator import ComplexityEstimator, evaluate_supervised
+
+__all__ = ["ComplexityEstimator", "evaluate_supervised"]

cejsp/graphs.py

@@ -0,0 +1,3 @@
+from xai_complex.graphs import extract_instance_features
+
+__all__ = ["extract_instance_features"]

cejsp/instances.py

@@ -0,0 +1,3 @@
+from xai_complex.instances import normalize_instance, summarize_instance
+
+__all__ = ["normalize_instance", "summarize_instance"]

cejsp/io.py

@@ -0,0 +1,3 @@
+from xai_complex.io import load_instance, parse_dzn, parse_taillard
+
+__all__ = ["load_instance", "parse_dzn", "parse_taillard"]

cejsp/labels.py

@@ -0,0 +1,3 @@
+from xai_complex.labels import SolverTargetCalibrator, status_to_complexity
+
+__all__ = ["SolverTargetCalibrator", "status_to_complexity"]

cejsp-0.4.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: cejsp
+Version: 0.4.1
+Summary: CEJSP: JSP Complexity Estimator for job shop scheduling instances
+Author: Planning and Scheduling Research Group
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=1.26
+Requires-Dist: pandas<3,>=2.1
+Requires-Dist: scikit-learn<2,>=1.4
+Requires-Dist: scipy<2,>=1.11
+Requires-Dist: joblib<2,>=1.3
+Provides-Extra: integration
+Requires-Dist: IGJSP==2.0.1; extra == "integration"
+Requires-Dist: ortools<10,>=9.15; extra == "integration"
+Provides-Extra: graphs
+Requires-Dist: torch>=2.2; extra == "graphs"
+Requires-Dist: torch-geometric>=2.5; extra == "graphs"
+Requires-Dist: networkx>=3; extra == "graphs"
+Requires-Dist: tqdm>=4; extra == "graphs"
+Provides-Extra: research
+Requires-Dist: ortools<10,>=9.15; extra == "research"
+Requires-Dist: catboost<2,>=1.2.10; extra == "research"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Dynamic: license-file
+
+# CEJSP: JSP Complexity Estimator
+
+La API 0.2 añade entrada directa JSON/DZN/Taillard y un clasificador supervisado reentrenable de cinco clases: **toy, easy, medium, hard, open**. Consultar [el flujo de cinco clases](docs/FIVE_CLASSES.md) para entrenar, clasificar y versionar referencias. Requiere un protocolo explícito y ejemplos etiquetados; no se incluye todavía una referencia real de cinco clases validada.
+
+Estimación empírica de dificultad de instancias de scheduling ya generadas. Este paquete no genera instancias ni modifica IGJSP.
+
+El código procede del proyecto XAI-COMPLEX. Conserva el extractor de características de grafos y ofrece la metodología por lotes del estimador ponderado, además de una API explícita para ajustar una referencia y predecir nuevas instancias sin recalibrar cada lote.
+
+## Instalación
+
+```powershell
+python -m pip install .
+python -m pip install ".[graphs,dev]"
+```
+
+El extra `graphs` instala las dependencias del extractor original. No se necesita IGJSP para instalar ni utilizar XAI-COMPLEX con instancias guardadas o características extraídas.
+
+## Usar instancias que ya tienes
+
+```python
+import json
+from pathlib import Path
+from cejsp.graphs import extract_instance_features
+from cejsp import ComplexityEstimator
+
+instances = [json.loads(p.read_text(encoding="utf-8"))
+             for p in Path("instancias_existentes").glob("*.json")]
+features = [extract_instance_features(inst) for inst in instances]
+model = ComplexityEstimator().fit(features)
+resultados = model.predict(features[:1])
+model.save("referencia.joblib")
+```
+
+Se necesitan al menos tres instancias de referencia con variación; para una calibración útil se requiere un conjunto representativo y una evaluación independiente. No se distribuye un modelo preentrenado ni se afirma precisión predictiva sin evaluación.
+
+Para evaluar una instancia nueva se carga la referencia ya ajustada:
+
+```python
+model = ComplexityEstimator.load("referencia.joblib", trusted=True)
+resultado = model.predict([extract_instance_features(instancia_nueva)])
+```
+
+Solo se deben cargar modelos de confianza. Se verifican esquema y versiones de dependencias del artefacto.
+
+## Mantener el análisis por lotes del proyecto
+
+```python
+import pandas as pd
+from cejsp import estimate_features
+
+features = pd.read_csv("graphs/features.csv").set_index("file")
+scores = estimate_features(features)
+scores.to_csv("complexity_scores.csv")
+```
+
+Esta ruta conserva Isolation Forest, LOF, MinCovDet, vecinos y prior del estimador ponderado. Sus normalizaciones y categorías son relativas al lote. La API `ComplexityEstimator` congela la referencia; usa los mismos cuatro tipos de señal sin prior y, opcionalmente, mezcla regresión supervisada. Es una variante inductiva explícita, no una reproducción numérica idéntica del análisis por lotes.
+
+La extracción usa el grafo JSP original. Las instancias con varias velocidades requieren `speed_index` explícito. El adaptador de entrada conserva todas las velocidades, fechas y disponibilidad; el extractor original rechaza FJSP porque su grafo de rutas fijas no modela la elección de máquina. No se declara compatibilidad científica con FJSP sin validar esa representación.
+
+`summarize_instance` ofrece estadísticas descriptivas; no sustituye las características de grafos del estimador original.
+
+## Etiquetas y evaluación
+
+`SolverTargetCalibrator` calibra señales de solver en el entrenamiento y mantiene fijos esos parámetros. `evaluate_supervised` ajusta objetivo y preprocesamiento dentro de cada pliegue. Usa `base_instance_id` o grupos equivalentes para que variantes de una misma instancia no aparezcan en entrenamiento y validación. Las etiquetas miden dificultad empírica respecto al solver, hardware y límites de tiempo; no una clase de complejidad computacional.
+
+Las correcciones de etiquetas cambian los resultados anteriores: se rechazan objetivos sin señales, se validan pesos, se renormalizan componentes disponibles y se conserva el significado absoluto del estado del solver.
+
+## Comandos
+
+```powershell
+cejsp fit reference_features.json referencia.joblib
+cejsp predict query_features.json referencia.joblib --trust-model
+python -m unittest discover -s tests -v
+```
+
+Los JSON de la CLI contienen listas de diccionarios de características numéricas, sin identificadores de texto. Los identificadores se mantienen por separado o en el índice del DataFrame para la API por lotes.
+
+Consulta `docs/PUBLICAR_PYPI.md` para construir, verificar y publicar.
+
+## Estado de esta candidata
+
+La ejecución `validacion-20261022-175907` del 22/10/2026 completó la validación: 32 pruebas sin omisiones en el entorno inicial y en instalaciones separadas de wheel y sdist, `pip check` correcto, 162 JSON válidos y flujo completo con 20 benchmarks en los tres entornos. Ambos artefactos superan `twine check --strict`. La invariancia individual/lotes se comprueba con tolerancia absoluta `1e-9` e igualdad de categorías y señales; la persistencia no cambia las puntuaciones. Esto valida funcionamiento y distribución, no precisión científica ni mejoras de rendimiento. No se ha publicado. Consultar `RESULTADOS.md` en la raíz del repositorio para el historial.
+
+Las etiquetas necesitan el mismo identificador completo que las características. No se infieren correspondencias a partir del tamaño, configuración o semilla, ni se promedian registros repetidos automáticamente. Por ejemplo, `10_10-0-1-cp-sat` no se convierte silenciosamente en `10-10-0.pt`: la configuración y el protocolo del solver deben resolverse antes mediante una correspondencia explícita y verificada. Para variantes, incluir `base_instance_id` en todas las etiquetas o pasar `groups` a `evaluate_supervised`; el resultado incluye los índices de cada pliegue para auditar su separación.
+
+`fit_instances(..., speed_index=...)` y `predict_instances(..., speed_index=...)` permiten la proyección explícita de velocidad. La invariancia por lote pertenece a la API inductiva; no se exige al análisis relativo por lotes.
+
+## Nombre e interoperabilidad
+
+La distribución se llama cejsp y el comando principal es cejsp. Los imports xai_complex y el comando anterior se conservan por compatibilidad. Las clases mantienen su identidad y los esquemas de persistencia anteriores para permitir cargar referencias guardadas; no se duplica el estimador. La disponibilidad del nombre en PyPI no está verificada. La validación completa anterior corresponde a la distribución xai-complex; CEJSP requiere repetir la validación tras el cambio de nombre.
+
+
+## Mejora supervisada CEJSP 0.3.0
+
+Referencia recomendada: `models/jsplib-8a6e36ef3126-v2/reference.joblib`, características estructurales y Extra Trees. Se conservan las referencias anteriores. Resultados, limitaciones y experimentos IGJSP: `evaluation/MEJORA_CLASIFICADOR.md`. El aumento con pseudoetiquetas no se incorpora por empeorar el resultado controlado. No hay validación externa de dificultad IGJSP.
+
+
+## Estudio easy y referencias 0.4.0
+
+Se completaron cinco rondas de nuevas variables, parámetros y selección dentro de los pliegues. No se alcanzó el 95% fuera del entrenamiento. El perfil de acierto global obtiene 84,19% exploratorio; el orientado a easy reconoce 7/15 casos con 79,41% global y precisión easy de 21,21%. Son perfiles experimentales con distintos compromisos; los modelos anteriores se conservan. Informe y comandos: `evaluation/RESULTADOS_EASY.md`; perfiles: `models/PROFILES.json`. Las sondas añaden resolución limitada durante inferencia.

cejsp-0.4.1.dist-info/RECORD

@@ -0,0 +1,40 @@
+cejsp/__init__.py,sha256=mtLu33dzYndlt4JwoXtGCWi4N6tISjxl38g51KoSU6o,878
+cejsp/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+cejsp/batch.py,sha256=KlzWt9bn4wGT41zc5nWwyrONwGL2lO8jpnNjaprtiQE,81
+cejsp/classifier.py,sha256=wBEGU0pbNneWi8R7WtzsbrejzcAsn-1J8YU_JWT43lM,200
+cejsp/cli.py,sha256=30XX4YNBxtogAb09VTbhfd8PIZ91eKwJm5xqILGY8_M,53
+cejsp/estimator.py,sha256=jVGQ01oUkZb8_sjoHzfZt_vk2izhP5Vt-7pm-oup5yg,133
+cejsp/graphs.py,sha256=Evm6aMsee8cnooTTBZwGJUtFzsgQHEfbcD-bw-oMgcM,98
+cejsp/instances.py,sha256=3ta5nvxkh1t3-f1HTknZY-MgYdPnkDVbl7s0dAW925E,129
+cejsp/io.py,sha256=jlT4Ve5jni_xitx579RCQpdTf71UTphnBYGtDEXQC1A,128
+cejsp/labels.py,sha256=ME5UzlcORaV91PM5M046A5uyp48CKvmJz1xbOjyiM84,138
+cejsp-0.4.1.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
+xai_complex/__init__.py,sha256=jLg7QSlW1-g79q5x9-4LWjFqFPxbGpHrla-bQun4qsg,625
+xai_complex/_graph_builder.py,sha256=GfivfJ51T5l0l_Ieu1cpR8R-O_5QLqmnWML1ETl1ewE,12393
+xai_complex/_graph_features.py,sha256=JSxemLlPwDLDkY0ML-Dv-9p-Z81zmh4qzRfpOiRmMYo,19901
+xai_complex/batch.py,sha256=VSv7zhPbtIzLQ8_8WlFf_GYyq6P1ceZJ-8tMCy1uEHs,2085
+xai_complex/bottleneck.py,sha256=F5cU4lxFaGCmbbKOSEABKU6IoEJftX-NhSzHngj3bT8,3677
+xai_complex/calibration.py,sha256=wGFTA1fyIeRjDGrOAVGRk9xNocnyyJgU9slxOBfo5Ug,3792
+xai_complex/categories.py,sha256=l4G0N7_Rs-p-u9H8OYTbFQ7Q92gwscs3tI9FO_fP6z0,618
+xai_complex/classifier.py,sha256=BzHg5Hvlz7cL5tBkni2Q3l6yAoMnp2vsQZbpStXHVCs,16363
+xai_complex/cli.py,sha256=vzjMQiuHPuE-9jLKD07yfj46kNeomNy460ivwwIczYY,3134
+xai_complex/cumulative.py,sha256=ZmHGa9YCrs4dF1pyGqmkE7cKCB8x3-CJ3DEZbfKIi8M,3443
+xai_complex/estimator.py,sha256=1QfFW1dZ0-wNJ37PbtkK4T_d4uNUSRA4qM3VG9f3YDc,10638
+xai_complex/feature_selector.py,sha256=SjGNLJgRdXW5BsHFNFfXF6yuDQfFbL8cKyCxo7UMzEc,1712
+xai_complex/graphs.py,sha256=b4LJYuzxb-wBMgVHUvELXU8TNxqxjjtkzwTtGOfNEG8,3183
+xai_complex/instances.py,sha256=qVSF7rxV0HTXpjaSILEEWM6ZmyDENAWSRD7ukr7W9q8,8894
+xai_complex/io.py,sha256=EhZ3Y2qM0xbo3YflTJNfpXQYkw0-kUiR5NUOvHKcgQg,8540
+xai_complex/labels.py,sha256=f-Qo9dnuxipkRHkJVJP1RT5w8dnJc2NlpaXb4SxT7t4,4353
+xai_complex/landscape.py,sha256=PAlldRvIPM4A9IhzxeZRejK7b_dl7ZySE_q7ouCwwTI,5232
+xai_complex/proof_features.py,sha256=ZXOl44kZ7eE--3gzYXwuvRYDqpG5Y8BfyYwue9OrT5g,5366
+xai_complex/research.py,sha256=LC_j0EJpfFVtQ1-tUjlVcBbFd8vw4JKtYxo96Ubc7FU,20509
+xai_complex/search_features.py,sha256=UV845tlVt78ZVhuYhiCBZTEexGLxSjjsOMKkQ6lbFRI,6370
+xai_complex/specialists.py,sha256=A7ekFzZrQ73telwmudwz70-Wa5Q8qeG0Fl9n5VyRHvQ,3960
+xai_complex/structural.py,sha256=FQyRtIbY3VnHVJaVgDOxlKQn3TonfnZUKDUWjlQIDYA,3801
+xai_complex/subset_voting.py,sha256=RO65oBb4fWnJaUBFheJBNNhise79i0SGihhI-HiXRQ4,2848
+xai_complex/supervised.py,sha256=uOOq83d_-xYxbUwkEtNjPbwnkSWC84fd1cfJ_xk_w9I,2529
+cejsp-0.4.1.dist-info/METADATA,sha256=mCgdIzjMFq8FgsAGM8N53R6sC11h09BWctKHJZVdQBs,8964
+cejsp-0.4.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+cejsp-0.4.1.dist-info/entry_points.txt,sha256=s9YGng9OkNOf_uhQJ9HIifrkbYUr06RFcBSxnS9m1Cs,76
+cejsp-0.4.1.dist-info/top_level.txt,sha256=CcmLFtEFMuF-elLUsLlsuDDrcCeiB-wQUSh6ZMQqlHM,18
+cejsp-0.4.1.dist-info/RECORD,,

cejsp-0.4.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cejsp-0.4.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cejsp = cejsp.cli:main
+xai-complex = xai_complex.cli:main

cejsp-0.4.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Planning and Scheduling Research Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cejsp-0.4.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cejsp
+xai_complex

xai_complex/__init__.py

@@ -0,0 +1,16 @@
+"""Empirical scheduling difficulty; no training or filesystem work on import."""
+
+from .instances import summarize_instance, normalize_instance
+from .labels import SolverTargetCalibrator, status_to_complexity
+from .batch import estimate_features
+
+__version__ = "0.4.1"
+__all__ = ["normalize_instance", "summarize_instance",
+           "SolverTargetCalibrator", "status_to_complexity", "ComplexityEstimator", "estimate_features"]
+
+
+def __getattr__(name):
+    if name == "ComplexityEstimator":
+        from .estimator import ComplexityEstimator
+        return ComplexityEstimator
+    raise AttributeError(name)

xai_complex/_graph_builder.py

@@ -0,0 +1,293 @@
+import os
+from collections import defaultdict
+from itertools import permutations
+from typing import Any, Dict, List, Tuple, Optional
+
+import itertools
+import numpy as np
+import torch
+
+from torch_geometric.data import HeteroData
+from tqdm import tqdm
+
+
+
+def extract_operations_strict(data: Dict[str, Any]) -> List[Tuple[int, int, int, float, float]]:
+    """
+    Extrae operaciones asumiendo estructura estricta:
+      - ProcessingTime: (J, O) o (J, O, 1)
+      - Orden:          (J, O)  con id de máquina por operación
+      - EnergyConsumption: (J, O) o (J, O, 1)
+    """
+    PT = np.asarray(data["ProcessingTime"])
+    OR = np.asarray(data["Orden"])
+    EC = np.asarray(data["EnergyConsumption"])
+
+    num_jobs = int(data["numJobs"])
+    if (PT.ndim == 3 and PT.shape[2] != 1) or (EC.ndim == 3 and EC.shape[2] != 1):
+        raise ValueError("Seleccione explícitamente una velocidad antes de construir el grafo JSP")
+    if any(k in data for k in ("AllowedMachines", "allowed_machines", "available_machines", "AVJM", "avail_machines", "machine_mask")):
+        raise ValueError("El grafo original de rutas fijas no representa FJSP")
+
+
+    if PT.ndim == 3:
+        num_ops = PT.shape[1]
+        get_pt = lambda j, o: float(PT[j, o, 0])
+    elif PT.ndim == 2:
+        num_ops = PT.shape[1]
+        get_pt = lambda j, o: float(PT[j, o])
+    else:
+        raise ValueError("ProcessingTime tiene una forma inesperada. Esperado (J,O[,1]).")
+
+
+    if EC.ndim == 3:
+        get_ec = lambda j, o: float(EC[j, o, 0])
+    elif EC.ndim == 2:
+        get_ec = lambda j, o: float(EC[j, o])
+    else:
+        raise ValueError("EnergyConsumption tiene una forma inesperada. Esperado (J,O[,1]).")
+
+    ops = []
+    for j in range(num_jobs):
+        for o in range(num_ops):
+            proc_time = get_pt(j, o)
+            energy = get_ec(j, o)
+            mach = int(OR[j, o])
+            ops.append((j, o, mach, proc_time, energy))
+    return ops
+
+
+def _maybe_get(mat: Dict[str, Any], keys: List[str]) -> Optional[np.ndarray]:
+    """Devuelve np.array si existe alguna de las keys y no está vacía."""
+    for k in keys:
+        if k in mat and mat[k] is not None:
+            arr = np.asarray(mat[k])
+            if arr.size > 0:
+                return arr
+    return None
+
+
+def _flatten_generator_features(inst: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Normaliza los nombres de métricas precomputadas del generador y
+    las devuelve como escalares Python (o np.* convertidos).
+    Mantiene también una copia del dict original 'features' para referencia.
+    """
+    out: Dict[str, Any] = {}
+
+    if "numJobs" in inst:  out["n_jobs"] = int(inst["numJobs"])
+    if "numMchs" in inst:  out["n_machs"] = int(inst["numMchs"])
+    if "speed"   in inst:  out["speed"]  = int(inst["speed"])
+    if "rddd"    in inst:  out["rddd"]   = int(inst["rddd"])
+
+
+    if "max_makespan" in inst: out["makespan_max"] = int(inst["max_makespan"])
+    if "min_makespan" in inst: out["makespan_min"] = int(inst["min_makespan"])
+
+    if "max_min_makespan" in inst:
+        out["makespan_range"] = int(inst["max_min_makespan"])
+
+
+    # el generador usa dos variantes de nombre: max_energy/min_energy y max_sum_energy/min_sum_energy
+    if "max_energy" in inst: out["energy_sum_max"] = int(inst["max_energy"])
+    if "min_energy" in inst: out["energy_sum_min"] = int(inst["min_energy"])
+    if "max_min_energy" in inst: out["energy_sum_range"] = int(inst["max_min_energy"])
+
+    feats = inst.get("features", {})
+    if isinstance(feats, dict):
+        # sobreescribimos si están también en 'features' con otros nombres
+        if "max_makespan" in feats: out["makespan_max"] = int(feats["max_makespan"])
+        if "min_makespan" in feats: out["makespan_min"] = int(feats["min_makespan"])
+
+        if "max_sum_energy" in feats: out["energy_sum_max"] = int(feats["max_sum_energy"])
+        if "min_sum_energy" in feats: out["energy_sum_min"] = int(feats["min_sum_energy"])
+
+
+        if "max_processing_time_value" in feats: out["p_value_max"] = int(feats["max_processing_time_value"])
+        if "min_processing_time_value" in feats: out["p_value_min"] = int(feats["min_processing_time_value"])
+        if "mean_processing_time_value" in feats: out["p_value_mean"] = float(feats["mean_processing_time_value"])
+
+        if "max_energy_value" in feats: out["e_value_max"] = int(feats["max_energy_value"])
+        if "min_energy_value" in feats: out["e_value_min"] = int(feats["min_energy_value"])
+        if "mean_energy_value" in feats: out["e_value_mean"] = float(feats["mean_energy_value"])
+
+
+        if "min_window" in feats: out["window_min"] = float(feats["min_window"])
+        if "mean_window" in feats: out["window_mean"] = float(feats["mean_window"])
+        if "max_window" in feats: out["window_max"] = float(feats["max_window"]) if feats.get("max_window") is not None else None
+        if "overlap" in feats: out["overlap"] = float(feats["overlap"])
+        if "max_tardiness" in feats: out["max_tardiness"] = float(feats["max_tardiness"])
+
+
+        out["gen_features"] = feats
+
+    return out
+
+
+class GraphBuilderStrict:
+    def __init__(self, instance_dict: Dict[str, Any]):
+        self.data_dict = instance_dict
+        self.num_jobs = int(instance_dict["numJobs"])
+        self.num_machs = int(instance_dict["numMchs"])
+        self.operations = extract_operations_strict(instance_dict)
+
+        self.node_features: List[List[float]] = []
+        self.node_mapping: Dict[Tuple[int, int], int] = {}
+        self.darcs: List[List[int]] = []
+        self.carcs: List[List[int]] = []
+        self.data = None
+
+        self.build_graph()
+
+    def _ops_per_job(self) -> int:
+        PT = np.asarray(self.data_dict["ProcessingTime"])
+        return PT.shape[1] if PT.ndim in (2, 3) else int(round(len(self.operations) / self.num_jobs))
+
+    def build_graph(self):
+
+        node_id = 0
+        include_virtual = True
+
+        if include_virtual:
+            self.node_features.append([0.0, -1.0])
+            self.node_mapping[("source", 0)] = node_id
+
+        op_node_index: List[int] = []
+        for (job_id, op_id, mac_id, proc_time, energy) in self.operations:
+            node_id += 1
+            self.node_features.append([float(proc_time), float(mac_id)])
+            self.node_mapping[(job_id, op_id)] = node_id
+            op_node_index.append(node_id)
+
+        if include_virtual:
+            node_id += 1
+            self.node_features.append([0.0, -1.0])
+            self.node_mapping[("sink", 0)] = node_id
+
+
+        origen, destino = [], []
+        for j in range(self.num_jobs):
+            nodes = [self.node_mapping[(j, o)] for o in range(self._ops_per_job())]
+            if include_virtual:
+                origen.append(self.node_mapping[("source", 0)]); destino.append(nodes[0])
+            for i in range(len(nodes) - 1):
+                origen.append(nodes[i]); destino.append(nodes[i + 1])
+            if include_virtual:
+                origen.append(nodes[-1]); destino.append(self.node_mapping[("sink", 0)])
+        self.carcs = [origen, destino]
+
+
+        mach_to_nodes = defaultdict(list)
+        for (job_id, op_id, mac_id, proc_time, energy) in self.operations:
+            nid = self.node_mapping[(job_id, op_id)]
+            mach_to_nodes[mac_id].append(nid)
+
+        origen_d, destino_d = [], []
+        for nodes in mach_to_nodes.values():
+            if len(nodes) < 2:
+                continue
+            for a, b in permutations(nodes, 2):
+                origen_d.append(a); destino_d.append(b)
+        self.darcs = [origen_d, destino_d]
+
+
+        data = HeteroData()
+        data["node"].x = torch.tensor(self.node_features, dtype=torch.float)
+
+        data[("node", "conjunctive", "node")].edge_index = (
+            torch.tensor(self.carcs, dtype=torch.long) if len(self.carcs[0]) > 0
+            else torch.empty((2, 0), dtype=torch.long)
+        )
+        data[("node", "disjunctive", "node")].edge_index = (
+            torch.tensor(self.darcs, dtype=torch.long) if len(self.darcs[0]) > 0
+            else torch.empty((2, 0), dtype=torch.long)
+        )
+
+
+        N_ops = len(self.operations)
+        job_ids  = np.fromiter((j for (j, o, m, p, e) in self.operations), dtype=np.int64, count=N_ops)
+        op_ids   = np.fromiter((o for (j, o, m, p, e) in self.operations), dtype=np.int64, count=N_ops)
+        mach_ids = np.fromiter((m for (j, o, m, p, e) in self.operations), dtype=np.int64, count=N_ops)
+        P = np.fromiter((p for (j, o, m, p, e) in self.operations), dtype=np.float64, count=N_ops).reshape(N_ops, 1)
+        E = np.fromiter((e for (j, o, m, p, e) in self.operations), dtype=np.float64, count=N_ops).reshape(N_ops, 1)
+
+
+        op_cost = _maybe_get(self.data_dict, ["operationCost", "opCost", "operation_cost"])
+        if op_cost is not None:
+            op_cost = np.asarray(op_cost, dtype=np.float64).reshape(self.num_jobs, self._ops_per_job())
+            op_cost = op_cost.reshape(-1)
+
+
+        R = _maybe_get(self.data_dict, ["ReleaseDate", "Release", "R"])
+        D = _maybe_get(self.data_dict, ["DueDate", "Due", "D"])
+        if R is not None:
+            R = R.reshape(self.num_jobs, -1).astype(np.float64)
+            if R.shape[1] == 1:
+                R = np.repeat(R, self._ops_per_job(), axis=1)
+            R = R[:, :self._ops_per_job()].reshape(-1)
+        if D is not None:
+            D = D.reshape(self.num_jobs, -1).astype(np.float64)
+            if D.shape[1] == 1:
+                D = np.repeat(D, self._ops_per_job(), axis=1)
+            D = D[:, :self._ops_per_job()].reshape(-1)
+
+        # AVJM (si no existe, derivamos del uso de máquinas en cada job)
+        avjm = _maybe_get(self.data_dict, ["AllowedMachines", "allowed_machines", "AVJM", "avail_machines", "machine_mask"])
+        if avjm is None:
+            avjm = np.zeros((self.num_jobs, self.num_machs), dtype=np.int64)
+            for j in range(self.num_jobs):
+                used = np.unique(mach_ids[j * self._ops_per_job() : (j + 1) * self._ops_per_job()])
+                avjm[j, used] = 1
+        else:
+            avjm = (np.asarray(avjm) > 0).astype(np.int64)
+            if avjm.shape == (N_ops, self.num_machs):
+                tmp = np.zeros((self.num_jobs, self.num_machs), dtype=np.int64)
+                for j in range(self.num_jobs):
+                    mask = (job_ids == j)
+                    if np.any(mask):
+                        tmp[j] = (avjm[mask].max(axis=0) > 0).astype(np.int64)
+                avjm = tmp
+
+
+        setup_mat = _maybe_get(self.data_dict, ["Setup", "SetupTime", "setup", "mtt", "Changeover", "setup_matrix"])
+        if setup_mat is not None:
+            setup_mat = setup_mat.astype(np.float64)
+
+
+        data.n_jobs = int(self.num_jobs)
+        data.n_machs = int(self.num_machs)
+        data.P = torch.tensor(P, dtype=torch.float)
+        data.E = torch.tensor(E, dtype=torch.float)
+        data.job = torch.tensor(job_ids, dtype=torch.long)
+        data.machine = torch.tensor(mach_ids, dtype=torch.long)
+        data.op = torch.tensor(op_ids, dtype=torch.long)
+        data.op_node_index = torch.tensor(op_node_index, dtype=torch.long)
+
+        if op_cost is not None:
+            data.operation_cost = torch.tensor(op_cost, dtype=torch.float)
+
+        if R is not None: data.R = torch.tensor(R, dtype=torch.float)
+        if D is not None: data.D = torch.tensor(D, dtype=torch.float)
+        if setup_mat is not None: data.setup = torch.tensor(setup_mat, dtype=torch.float)
+        if avjm is not None: data.allowed_machines = torch.tensor(avjm, dtype=torch.long)
+
+
+        N_nodes = len(self.node_features)
+        op_mask = torch.zeros(N_nodes, dtype=torch.bool)
+        op_mask[data.op_node_index] = True
+        data["node"].op_mask = op_mask
+
+
+        if include_virtual:
+            data.source_idx = int(self.node_mapping[("source", 0)])
+            data.sink_idx = int(self.node_mapping[("sink", 0)])
+
+
+        gf = _flatten_generator_features(self.data_dict)
+
+        for k, v in gf.items():
+            setattr(data, k, v if not isinstance(v, np.generic) else v.item())
+
+        self.data = data
+
+