cejsp 0.4.1__tar.gz

cejsp-0.4.1/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/MANIFEST.in

@@ -0,0 +1,12 @@
+include LICENSE README.md
+recursive-include tests *.py
+recursive-include docs *.md
+include examples/quickstart.py
+include examples/training_manifest.template.json
+include verify_release.py
+include VALIDAR_WINDOWS.ps1
+include validate_real_inputs.py
+include validate_pipeline.py
+include validate_instance_formats.py
+
+include examples/test_igjsp_classifier.py

cejsp-0.4.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,100 @@
+# 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/VALIDAR_WINDOWS.ps1

@@ -0,0 +1,47 @@
+param([string]$Python = 'python', [string]$Instancias = (Join-Path $PSScriptRoot '..\TaillardInstancesJSON'))
+$ErrorActionPreference = 'Stop'
+$raiz = $PSScriptRoot
+$ejecucion = Join-Path $raiz ('validacion-' + (Get-Date -Format 'yyyyMMdd-HHmmss'))
+New-Item -ItemType Directory -Path $ejecucion | Out-Null
+$env:TEMP = $ejecucion
+$env:TMP = $ejecucion
+Start-Transcript -Path (Join-Path $ejecucion 'validacion.log')
+function Ejecutar {
+    param([string]$Programa, [string[]]$Argumentos)
+    & $Programa @Argumentos
+    if ($LASTEXITCODE -ne 0) { throw "Error $LASTEXITCODE al ejecutar $Programa $Argumentos" }
+}
+try {
+    $entorno = Join-Path $ejecucion 'entorno'
+    Ejecutar $Python @('-m', 'venv', $entorno)
+    $interprete = Join-Path $entorno 'Scripts\python.exe'
+    Ejecutar $interprete @('-m', 'pip', 'install', '--upgrade', 'pip')
+    Ejecutar $interprete @('-m', 'pip', 'install', "$raiz[graphs,dev,research]")
+    Ejecutar $interprete @('-m', 'pip', 'check')
+    Ejecutar $interprete @('-I', (Join-Path $raiz 'verify_release.py'))
+    Ejecutar $interprete @('-I', (Join-Path $raiz 'validate_instance_formats.py'), (Join-Path $raiz '..'), '--output', (Join-Path $ejecucion 'instance-formats.json'))
+    Ejecutar $interprete @('-I', (Join-Path $raiz 'validate_real_inputs.py'), $Instancias, '--output', (Join-Path $ejecucion 'real-inputs.json'))
+    Ejecutar $interprete @('-I', (Join-Path $raiz 'validate_pipeline.py'), $Instancias, '--output', (Join-Path $ejecucion 'pipeline.json'))
+    $dist = Join-Path $ejecucion 'dist'
+    Ejecutar $interprete @('-m', 'build', $raiz, '--outdir', $dist)
+    $archivos = @(Get-ChildItem -LiteralPath $dist -File | ForEach-Object FullName)
+    Ejecutar $interprete (@('-m', 'twine', 'check', '--strict') + $archivos)
+    foreach ($tipo in @('wheel', 'sdist')) {
+        $smoke = Join-Path $ejecucion $tipo
+        Ejecutar $Python @('-m', 'venv', $smoke)
+        $smokePython = Join-Path $smoke 'Scripts\python.exe'
+        if ($tipo -eq 'wheel') {
+            $archivo = (Get-ChildItem -LiteralPath $dist -Filter '*.whl' | Select-Object -First 1).FullName
+        } else {
+            $archivo = (Get-ChildItem -LiteralPath $dist -Filter '*.tar.gz' | Select-Object -First 1).FullName
+        }
+        Ejecutar $smokePython @('-m', 'pip', 'install', "$archivo[graphs,research]")
+        Ejecutar $smokePython @('-m', 'pip', 'check')
+        Ejecutar $smokePython @('-I', (Join-Path $raiz 'verify_release.py'))
+        Ejecutar $smokePython @('-I', (Join-Path $raiz 'validate_pipeline.py'), $Instancias, '--output', (Join-Path $ejecucion "$tipo-pipeline.json"))
+    }
+    Ejecutar $interprete @('-m', 'pip', 'freeze')
+    Write-Output "VALIDACION COMPLETA SIN OMISIONES. Resultados: $ejecucion"
+} finally {
+    Stop-Transcript
+}

cejsp-0.4.1/docs/FIVE_CLASSES.md

@@ -0,0 +1,90 @@
+# Una instancia, cinco clases y referencias reentrenables
+
+El flujo público de CEJSP 0.2.1 es `archivo existente → lector → características → modelo guardado → toy/easy/medium/hard/open`. La versión anterior de `ComplexityEstimator` se conserva con sus tres categorías; la nueva API es `JobShopComplexityClassifier` y necesita etiquetas supervisadas reales.
+
+## Significado de las clases
+
+Las cinco clases son dificultad empírica **según un protocolo declarado**, no clases de complejidad computacional. El protocolo debe definir solver, versión, hardware o entorno de referencia, criterio de éxito, límites y significado de cada etiqueta. `open` predicho no certifica que un problema sea históricamente abierto ni que no exista una solución óptima conocida. SATISFIED o alcanzar un timeout tampoco bastan para declarar un problema abierto científicamente.
+
+No se convierten los quintiles de una puntuación de anomalía en estas cinco etiquetas. El piloto anterior mostró que la mezcla inductiva no supera al control de tamaño. Por ello se añade un clasificador supervisado directo, Random Forest balanceado, como candidato explícito, sin sustituir ni atribuir una mejora demostrada al método anterior. Sus votos no son probabilidades calibradas y así se indica en cada salida.
+
+## Archivos admitidos
+
+- JSON de IGJSP, JSON nativo de JSPLIB, objetos de instancia y estructura normalizada CEJSP. Los nombres y las etiquetas de JSPLIB no se usan como características.
+- DZN con JOBS, MACHINES, SPEED, time, energy y precedence en arrays literales. La precedencia es rango por máquina, como en el modelo MiniZinc existente; el lector ordena las operaciones por esos rangos y conserva todas las velocidades. Rechaza restricciones o campos adicionales que no entiende, incluidas variantes de fechas aún no implementadas en el lector DZN, para no descartarlas silenciosamente.
+- Taillard/JSPLIB con cabecera jobs/máquinas y pares máquina/duración, como los benchmarks existentes, con o sin extensión. También bloques Times/Machines con matrices por trabajo. Admite IDs de máquina desde cero o uno y duraciones cero. El formato no aporta energía: se marca como ausente y las características de energía/coste energético no entran en el nuevo clasificador.
+
+Los JSON con fechas conservan el tratamiento ya existente. El extractor de grafos sigue requiriendo una velocidad explícita si hay varias y rechaza FJSP. No se declara compatibilidad con todas las variantes posibles de DZN o Taillard.
+
+## Entrenar una referencia
+
+Partir de `examples/training_manifest.template.json`. La plantilla tiene campos vacíos deliberadamente y no se puede entrenar sin completar el protocolo y las etiquetas. Cada ejemplo contiene un path relativo al manifiesto, una etiqueta y un identificador de instancia base para agrupar variantes en una evaluación posterior.
+
+El manifiesto necesita `schema: cejsp.training.v1`, `model_version`, `feature_backend` (graph por defecto, graph_approx con intermediación muestreada reproducible, o summary como variante descriptiva explícita), `protocol.id`, las cinco definiciones en `protocol.class_definitions`, y `examples`. Cada ejemplo es `{ "path": "instancias/ejemplo.json", "label": "easy", "base_instance_id": "ejemplo-base" }`.
+
+```powershell
+cejsp train dataset/manifest.json models/reference-v1.joblib
+```
+
+Se requieren ejemplos de las cinco clases y al menos dos por clase para permitir el ajuste; ese mínimo técnico no basta para validar un clasificador útil. No se entrena con labels inventadas. El artefacto guarda esquema, columnas, clases, protocolo, versión, fingerprint de entrenamiento, identificadores base, versiones de dependencias y backend de características.
+
+## Clasificar
+
+```powershell
+cejsp classify instancia.json models/reference-v1.joblib --trust-model
+cejsp classify instancia.dzn models/reference-v1.joblib --trust-model
+cejsp classify instancia_taillard models/reference-v1.joblib --trust-model
+```
+
+La salida incluye `category`, los votos de las cinco clases, `model_version`, `label_protocol`, identificador de instancia y señal de aplicabilidad. Estar dentro de los rangos de entrenamiento no garantiza generalización. Una instancia fuera de rango se marca expresamente; no se convierte automáticamente en `open`.
+
+```python
+from cejsp import JobShopComplexityClassifier
+model = JobShopComplexityClassifier.load("models/reference-v1.joblib", trusted=True)
+result = model.classify("instancia.dzn")
+print(result["category"])
+```
+
+Para comprobar solo lectura y normalización, sin modelo ni dependencias científicas:
+
+```powershell
+cejsp inspect instancia.dzn
+```
+
+## Reentrenar
+
+```powershell
+cejsp retrain dataset/manifest-v2.json models/reference-v2.joblib --previous models/reference-v1.joblib --trust-model
+```
+
+Es reentrenamiento completo con el conjunto incluido en el nuevo manifiesto, no aprendizaje incremental ni acumulación automática de los ejemplos antiguos. Hay que incluir explícitamente los ejemplos anteriores que se quieran conservar. Se exige otra versión y un archivo nuevo; se conserva el modelo previo y se registra su versión. Los artefactos joblib solo deben cargarse si son de confianza.
+
+## Referencia JSPLIB
+
+Se ha fijado la instantánea `8a6e36ef31263d36975e56fb481e0ba04e188d6f` de ScheduleOpt/benchmarks y sus etiquetas originales. La preparación, el entrenamiento y la evaluación están en `evaluation/train_jsplib.py`. La procedencia y licencia de datos están en `data/jsplib/README.md`.
+
+La referencia usa `graph_approx`: conserva el grafo original y sus características, con intermediación estimada sobre 100 nodos, semilla 42. Es una variante explícita, no una equivalencia numérica con la intermediación exacta. El artefacto conserva el backend y el número de muestras para usarlos también en inferencia. No se afirma una mejora de rendimiento sin una comparación controlada.
+
+El informe y el modelo quedan en `models/jsplib-8a6e36ef3126-v1/`. El test estratificado del 20% se reserva antes del ajuste; el diagnóstico adicional deja fuera familias completas. Se eliminan duplicados de contenido y se comprueba la separación de identificadores base. La referencia final se reajusta con los 272 casos elegibles después de evaluar; las métricas de test corresponden al modelo de evaluación independiente.
+
+```powershell
+.\.venv\Scripts\python.exe -m cejsp classify instancia.json models\jsplib-8a6e36ef3126-v1\reference.joblib --trust-model
+```
+
+El protocolo de origen utiliza pruebas de optimalidad y tiempos de motores de referencia: toy hasta un minuto, easy hasta diez minutos, medium hasta una hora, hard más de una hora y open sin prueba de optimalidad publicada en esa instantánea. Se usan las etiquetas de la tabla literalmente; las condiciones históricas no se reinterpretan como tiempos actuales del ordenador del usuario.
+
+Todavía se requiere evaluación externa con instancias IGJSP etiquetadas de forma independiente. Los votos del bosque no están calibrados y las clases minoritarias tienen pocos ejemplos. El informe registra las exclusiones y las métricas por clase, además de los controles de tamaño y clase mayoritaria.
+
+
+## Actualización 0.3.0
+
+La referencia recomendada es `models/jsplib-8a6e36ef3126-v2/reference.joblib`, backend `structural`, estimador `extra_trees`. El grafo y el estimador originales siguen disponibles. El nuevo manifiesto acepta `estimator_kind` y `n_estimators`. Véase `evaluation/MEJORA_CLASIFICADOR.md` para las comparaciones, incluidas selección anidada, familias y experimentos negativos de aumento de datos. Las métricas de la variante fija no equivalen a una evaluación externa del procedimiento de selección.
+
+`structural` y `hybrid` añaden señales de duración, carga y rutas. El backend estructural requiere JSP de permutación y rechaza fechas y alternativas de máquina no representadas. Las semillas, los identificadores y las etiquetas no forman parte de sus características. Los modelos con estos backends usan el esquema de persistencia v3 y requieren CEJSP 0.3.0.
+
+Se generaron 816 instancias con IGJSP 2.0.1. Su similitud no transfiere automáticamente la etiqueta del benchmark. El experimento con pseudoetiquetas empeoró los resultados y no se incorpora a la referencia recomendada. No se declara una mejora de easy ni de transferencia equilibrada entre familias.
+
+
+## Modos de investigación 0.4.0
+
+Ver `RESEARCH_MODES.md` para cotas, reglas constructivas, geometría, bloques críticos, sondas CP-SAT y alternativas especializadas. La persistencia nueva usa esquema v4 y conserva parámetros, pesos de decisión y presupuesto. El objetivo del 95% se evalúa fuera del entrenamiento y no está garantizado por aumentar características o workers.

cejsp-0.4.1/docs/PUBLICAR_PYPI.md

@@ -0,0 +1,46 @@
+# Publicación posterior
+
+No se ha publicado. No publicar esta candidata mientras haya pruebas omitidas o comprobaciones bloqueadas. El nombre `cejsp` y la versión `0.4.1` son propuestas; su disponibilidad no está comprobada.
+
+Desde PowerShell, ejecutar con un Python ejecutable y acceso a las dependencias:
+
+```powershell
+Set-Location 'D:\CODE\XAI-COMPLEX'
+& .\pypi\VALIDAR_WINDOWS.ps1 -Python python
+```
+
+El script instala `.[graphs,dev,research]`, exige pruebas sin omisiones, comprueba los JSON existentes y el flujo completo con 20 benchmarks, construye wheel y sdist, ejecuta `twine check --strict` y prueba las dos distribuciones en entornos separados con Python aislado (`-I`). Se detiene ante cualquier error. Los resultados quedan en `pypi/validacion-FECHA/`. Si los benchmarks están en otra ubicación, usar `-Instancias 'RUTA'`.
+
+Tras una ejecución satisfactoria, y solo cuando se autorice la publicación, seleccionar la carpeta exacta de esa ejecución:
+
+```powershell
+$release = Get-ChildItem .\pypi -Directory -Filter 'validacion-*' | Sort-Object Name | Select-Object -Last 1
+$pythonRelease = Join-Path $release.FullName 'entorno\Scripts\python.exe'
+$artifacts = @(Get-ChildItem (Join-Path $release.FullName 'dist') -File | ForEach-Object FullName)
+& $pythonRelease -m twine check --strict @artifacts
+& $pythonRelease -m twine upload --repository testpypi @artifacts
+```
+
+Comprobar que esa ejecución terminó con `VALIDACION COMPLETA SIN OMISIONES`. No elegir una ejecución fallida por ser la más reciente. Twine solicita las credenciales: usuario `__token__` y token específico del servicio. No guardar credenciales en el repositorio.
+
+Comprobar TestPyPI en otro entorno, descargando el paquete sin mezclar índices:
+
+```powershell
+python -m venv .testpypi-check
+& .\.testpypi-check\Scripts\python.exe -m pip download --index-url https://test.pypi.org/simple/ --no-deps cejsp==0.4.1 --dest .testpypi-download
+& .\.testpypi-check\Scripts\python.exe -m pip install '.\.testpypi-download\cejsp-0.4.1-py3-none-any.whl[graphs,research]'
+& .\.testpypi-check\Scripts\python.exe -I .\pypi\verify_release.py
+& .\.testpypi-check\Scripts\python.exe -I .\pypi\validate_pipeline.py .\TaillardInstancesJSON
+```
+
+Después de comprobar TestPyPI y recibir autorización para PyPI:
+
+```powershell
+& $pythonRelease -m twine upload @artifacts
+```
+
+Si el nombre está ocupado, cambiar `project.name` y reconstruir. Para una versión publicada, incrementar la versión en `pyproject.toml` y `src/xai_complex/__init__.py`, sincronizar la copia auxiliar de la raíz y volver a validar. Una versión publicada no se sustituye.
+
+Documentación oficial: https://packaging.python.org/en/latest/tutorials/packaging-projects/ y https://twine.readthedocs.io/en/stable/.
+
+El flujo de cinco clases requiere una nueva ejecución completa de VALIDAR_WINDOWS.ps1. Publicar únicamente artefactos cejsp-0.4.1* de esa ejecución, nunca los de validaciones anteriores.

cejsp-0.4.1/docs/RESEARCH_MODES.md

@@ -0,0 +1,44 @@
+# Modos de investigación CEJSP 0.4.0
+
+La versión mantiene los estimadores anteriores. Añade variables y alternativas supervisadas explícitas; no las presenta como equivalentes numéricos del estimador científico original.
+
+| Backend | Entrada adicional calculada | Requisito |
+|---|---|---|
+| structural | Distribución de tiempos, cargas y rutas | JSP de permutación, sin fechas |
+| search | structural, cotas preemptivas y cuatro reglas constructivas | Mismo contrato; admite tiempos reales |
+| probe | search y sonda CP-SAT | OR-Tools y tiempos enteros |
+| landscape | search, geometría de orden y bloques críticos de un schedule constructivo | Mismo contrato estructural |
+| trajectory | landscape, sonda corta de 0,2 unidades deterministas y otra de probe_budget | OR-Tools, tiempos enteros; mayor coste de inferencia |
+
+Los presupuestos deterministas no son segundos de pared. Las sondas usan un worker y semilla fija; la extracción se puede paralelizar entre instancias. Una prueba temprana de optimalidad evita repetir una búsqueda más larga innecesariamente. Ni una prueba local de optimalidad ni un timeout sustituyen la etiqueta histórica del protocolo JSPLIB.
+
+Los estimadores configurables son random_forest, extra_trees, hist_gradient, rbf_svm, ensemble, catboost, ordinal_forest, easy_specialist y selected_easy. La alternativa ordinal presupone un orden empírico de etiquetas: es una hipótesis de modelado, no una demostración de que open tenga siempre mayor dificultad intrínseca. El especialista combina un modelo multiclase con un clasificador easy frente al resto. selected_easy ordena variables mediante información mutua multiclase y easy frente al resto; la selección se ajusta exclusivamente dentro del entrenamiento de cada pliegue.
+
+Instalación para estos estudios:
+
+```powershell
+python -m pip install './pypi[graphs,dev,research]'
+```
+
+Los manifiestos de entrenamiento admiten n_jobs, estimator_params, class_decision_weights y probe_budget. Los pesos de decisión deben ser positivos y contener las cinco clases. Sus salidas son votos ajustados, sin calibración de probabilidad. Las configuraciones nuevas se guardan con esquema v4; requieren CEJSP 0.4.0. Los artefactos anteriores siguen siendo compatibles si coinciden sus dependencias.
+
+Para repetir las rondas completas desde la raíz, usando carpetas de salida nuevas o conservando las anteriores:
+
+```powershell
+.\.venv\Scripts\python.exe evaluation\study_easy.py --workers 8 --out models\nuevo-estudio
+.\.venv\Scripts\python.exe evaluation\analyze_easy_variables.py
+.\.venv\Scripts\python.exe evaluation\study_specialists.py --workers 4 --out models\nuevo-especialista
+.\.venv\Scripts\python.exe evaluation\study_trajectory.py --workers 12 --out models\nueva-trayectoria
+```
+
+Los scripts de especialistas y trayectoria usan sus carpetas de resultados declaradas y no sustituyen una referencia existente. Sus rutas de cohortes son locales al repositorio. Los manifiestos finales permiten reentrenar mediante el comando público, con otra versión y salida:
+
+```powershell
+cejsp retrain dataset/manifest-v2.json models/reference-v2.joblib --previous models/reference-v1.joblib --trust-model
+```
+
+La selección de características, modelos y multiplicadores debe repetirse dentro de cada pliegue. El comando train o retrain solo ajusta el manifiesto: no ejecuta automáticamente la validación anidada. Ningún porcentaje del ajuste a todos los datos certifica el objetivo del 95%.
+
+Las referencias, predicciones fuera del ajuste, planes, variables y limitaciones se conservan en models/jsplib-easy-v5, models/jsplib-easy-v6-specialists y models/jsplib-easy-v7-trajectory. El estudio está en evaluation/VARIABLES_EASY.md. Estos resultados son internos sobre una cohorte ya explorada; falta un conjunto externo etiquetado de IGJSP.
+
+La quinta ronda se repite con `python evaluation/study_selected_easy.py --workers 8 --out models/nueva-seleccion`. El resultado conjunto está en evaluation/RESULTADOS_EASY.md. No se alcanzó el 95% fuera del entrenamiento. Para ejecutar los scripts contra la fuente actual, fijar PYTHONPATH a pypi/src y reinstalar la versión final al validar el wheel.

cejsp-0.4.1/docs/RESULTADOS.md

@@ -0,0 +1,53 @@
+# Estado de la entrega
+
+Fecha: 22 de octubre de 2026.
+
+## Alcance
+
+Correcciones de XAI-COMPLEX y carpeta de distribución independiente. IGJSP no se modifica, no se incluye como dependencia y no se genera ninguna instancia. El paquete recibe instancias existentes o sus características.
+
+Las modificaciones están preparadas en una copia: el entorno no permite escribir en D:\CODE\XAI-COMPLEX. APLICAR_CAMBIOS.ps1 comprueba hashes y prepara copias de seguridad antes de trasladarlas al repositorio original; no se ha ejecutado sobre ese directorio.
+
+## Cambios
+
+- Estado INFEASIBLE separado de FEASIBLE.
+- Límites de vecinos según el número de muestras y error explícito para referencias insuficientes.
+- Preprocesamiento y calibración del objetivo ajustados dentro de cada pliegue en los estimadores ponderados.
+- Evaluación supervisada compartida; cada modelo de validación se entrena una vez y se reutiliza para obtener sus predicciones.
+- Rechazo de etiquetas sin señales, pesos inválidos, identificadores ambiguos y objetivos constantes.
+- Renormalización de pesos por señales disponibles; el estado del solver conserva su escala absoluta.
+- Exportación de características sin eliminar la última fila ni forzar semilla cero.
+- Retirada de la supresión global de avisos.
+- Fechas por trabajo expandidas a sus operaciones y selección explícita de velocidad antes de construir el grafo original.
+- Rechazo explícito de FJSP en el grafo de rutas fijas; no se convierte silenciosamente en JSP.
+- Semilla fija en centralidad aproximada y propagación de errores de generación de grafos.
+- Limpieza de comentarios decorativos y comprobación de que esa pasada conserva el AST.
+- API de análisis por lotes basada en el estimador ponderado original, más variante inductiva explícita con referencia persistente.
+
+El estimador básico estimate_complexity.py conserva su carácter experimental: se corrigen incompatibilidades dimensionales y tamaños fijos, y los identificadores arbitrarios de KMeans se sustituyen por distancia al centroide. Esta corrección cambia sus puntuaciones. Para el paquete se usa como referencia el estimador ponderado, no esa variante experimental.
+
+## Validación
+
+- Pruebas de contratos de entrada, fechas, velocidades, disponibilidad, etiquetas y regresiones de código ejecutadas con Python 3.12.14.
+- 23 pruebas descubiertas: 16 pasan y 7 se omiten por dependencias ausentes.
+- Las 7 omitidas cubren el estimador, persistencia, invariancia por lote, evaluación agrupada e integración de grafos. No se consideran aprobadas.
+- Los contratos utilizan fixtures sintéticos. Además se comprobaron normalización y estadísticas descriptivas de los 162 JSON reales de TaillardInstancesJSON: 162 pasan tras corregir el rechazo de una operación de duración cero en orb07, presente también en el archivo original. Esta comprobación no ejecuta grafos ni el estimador, y no demuestra compatibilidad con todos los objetos de IGJSP.
+- Compilación sintáctica de los módulos del paquete y de la copia de scripts.
+- Construcción de wheel y sdist con setuptools. Instalación del wheel en un entorno aislado usando --no-deps; esto solo valida distribución e importaciones ligeras.
+- No se ha podido ejecutar twine check ni instalar las dependencias ausentes: las descargas fallan con error de resolución DNS. No se ha publicado en TestPyPI ni PyPI.
+- No hay mediciones de rendimiento ni resultados científicos nuevos. No se afirma equivalencia numérica con resultados anteriores tras corregir etiquetas y validación.
+
+## Pendiente antes de publicar
+
+Se ha repetido la instalación de las dependencias en un entorno separado, tanto con la configuración disponible como indicando PyPI explícitamente: falla. La consulta directa a PyPI devuelve error de resolución DNS. La caché contiene binarios para Python 3.11, pero ese intérprete devuelve acceso denegado al ejecutarlo en esta sesión; el intérprete ejecutable disponible es Python 3.12.14. No se ha eludido esa restricción ni se han sustituido las bibliotecas por simulaciones.
+
+VALIDAR_WINDOWS.ps1 realiza la validación completa desde un PowerShell con acceso a las dependencias. Su sintaxis ha sido comprobada. No está ejecutado con éxito aquí.
+
+Instalar .[graphs,dev], ejecutar verify_release.py sin omisiones, verificar las rutas ponderadas con los CSV reales del proyecto y probar extracción con JSON/objetos reales guardados. Ejecutar twine check, instalar el sdist y validar TestPyPI según PUBLICAR_PYPI.md. Hasta entonces esta entrega es una candidata de trabajo, no una versión completamente validada.
+
+## Revisión antislop posterior
+
+PASS, R-31: comentarios decorativos retirados; la pasada de comentarios verifica igualdad de AST.
+PASS, R-36: el informe distingue resultados ejecutados y pruebas bloqueadas; no se inventan métricas.
+Las reglas de UI, navegación, tipografía y accesibilidad no aplican a esta biblioteca Python.
+La validación funcional de publicación permanece pendiente; no se declara un PASS global.

cejsp-0.4.1/examples/quickstart.py

@@ -0,0 +1,9 @@
+import json
+from pathlib import Path
+from cejsp import ComplexityEstimator
+
+reference = json.loads(Path("reference_features.json").read_text(encoding="utf-8"))
+model = ComplexityEstimator().fit(reference)
+model.save("reference.joblib")
+query = json.loads(Path("query_features.json").read_text(encoding="utf-8"))
+print(model.predict(query))

cejsp-0.4.1/examples/test_igjsp_classifier.py

@@ -0,0 +1,43 @@
+"""Real integration smoke test: IGJSP -> native JSON -> CEJSP classification."""
+import argparse,json,time,sys
+from importlib.util import find_spec
+from pathlib import Path
+from hashlib import sha256
+from importlib.metadata import version
+# Direct execution from a checkout does not put pypi/src on sys.path.
+# Keep installed distributions preferred so artifact checks still test them.
+if find_spec('cejsp') is None:
+    source = Path(__file__).resolve().parents[1] / 'src'
+    if not (source / 'cejsp' / '__init__.py').is_file():
+        raise SystemExit('CEJSP is not installed and local sources are unavailable. Install cejsp[integration] in this Python environment.')
+    sys.path.insert(0, str(source))
+
+from IGJSP.generador import Generator
+from cejsp import JobShopComplexityClassifier,CATEGORIES
+from cejsp.io import load_instance
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--model',type=Path,required=True,help='Trusted CEJSP model')
+    p.add_argument('--output',type=Path,required=True,help='Empty output directory')
+    p.add_argument('--jobs',type=int,default=6);p.add_argument('--machines',type=int,default=6);p.add_argument('--seed',type=int,default=42)
+    a=p.parse_args()
+    if min(a.jobs,a.machines)<1:p.error('Dimensions must be positive')
+    a.output.mkdir(parents=True,exist_ok=True)
+    if any(a.output.iterdir()):p.error('Use an empty output directory')
+    started=time.perf_counter()
+    obj=Generator(json=False,dzn=False,taillard=False).generate_new_instance(jobs=a.jobs,machines=a.machines,speed=1,ReleaseDateDueDate=0,distribution='uniform',seed=a.seed,instance_type='JSP')
+    path=a.output/'instance.json';obj.saveJsonFile(str(path))
+    instance=load_instance(path)
+    if len(instance['jobs'])!=a.jobs or instance['n_machines']!=a.machines:raise AssertionError('Generator dimensions differ')
+    model=JobShopComplexityClassifier.load(a.model,trusted=True)
+    prediction=model.classify(path)
+    if prediction['category'] not in CATEGORIES:raise AssertionError('Unexpected class')
+    loaded=model.load(a.model,trusted=True)
+    if loaded.classify(path)!=prediction:raise AssertionError('Reload changed prediction')
+    result={'passed':True,'generator':'IGJSP','generator_version':version('IGJSP'),'seed':a.seed,'jobs':a.jobs,'machines':a.machines,'model_sha256':sha256(a.model.read_bytes()).hexdigest(),'classification':prediction,'ground_truth_available':False,'seconds':time.perf_counter()-started}
+    (a.output/'result.json').write_text(json.dumps(result,indent=2),encoding='utf-8')
+    print(json.dumps(result,indent=2))
+
+if __name__=='__main__':main()

cejsp-0.4.1/examples/training_manifest.template.json

@@ -0,0 +1,11 @@
+{
+  "schema": "cejsp.training.v1",
+  "model_version": "reference-v1",
+  "feature_backend": "graph",
+  "speed_index": null,
+  "protocol": {
+    "id": "",
+    "class_definitions": {"toy": "", "easy": "", "medium": "", "hard": "", "open": ""}
+  },
+  "examples": [{"path": "REPLACE_WITH_INSTANCE_PATH", "label": null, "base_instance_id": ""}]
+}