Predicción de degradación de baterías: ¿qué modelos abiertos predicen la vida útil restante a partir de datos de ciclado?

Las baterías normalmente se consideran al final de su vida útil (end-of-life) cuando su capacidad cae al 80% de la capacidad inicial [11]. Llegar a ese punto lleva mucho tiempo en condiciones de prueba: las pruebas de degradación de baterías consumen tiempo porque la pérdida de capacidad no lineal ocurre durante meses o años antes del final de la vida útil [11]. Esto significa que cualquier modelo RUL que necesite datos de ciclado de longitud completa para entrenar es costoso de construir y lento de validar, lo que motiva métodos que necesitan solo unos pocos ciclos tempranos o una única curva de carga.

La degradación en sí no es un único proceso. Los modos de degradación de baterías comúnmente reportados incluyen pérdida de materiales activos en el electrodo positivo, pérdida de materiales activos en el electrodo negativo y pérdida de inventario de litio [12]. Debido a que estos modos pueden combinarse de manera diferente entre químicas, formatos y condiciones de operación, un modelo entrenado en un entorno estrecho puede no transferirse a otro. Esta es exactamente la preocupación de generalización que se plantea sobre los conjuntos de datos existentes.

Los conjuntos de datos de vida de batería existentes a menudo son pequeños y están restringidos a baterías de iones de litio de pequeña capacidad probadas bajo condiciones de laboratorio estrechas, lo que genera preocupaciones sobre la generalización [11]. Los benchmarks inconsistentes y limitados hacen que la efectividad de las líneas base no sea clara y dejan incierto si los modelos populares en otros campos de series temporales son efectivos para Battery Life Prediction [11]. Así que la pregunta que hace el lector, qué familia de modelado gana, actualmente no es respondible a partir de un único estudio controlado; solo es respondible de manera fragmentaria, una comparación propia de un artículo a la vez.

Esto importa para un constructor porque la elección de ingeniería correcta depende de lo que esté disponible: un modelo físico detallado de la celda, un gran conjunto de datos etiquetado de vida de ciclo completa, o solo un puñado de mediciones tempranas de vida. Las secciones a continuación recorren qué es realmente cada familia de métodos, cómo funciona cada uno mecanicistamente, qué midió cada uno y contra qué línea base, y luego dan un procedimiento concreto y código para construir una canalización defendible.

Dos familias amplias se contrastan directamente en las fuentes. La capacidad y la resistencia en línea de la batería se pueden predecir usando modelos algebraicos de orden reducido, observadores de estado como extended Kalman filters y particle filters acoplados con equivalent-circuit o electrochemical models, y métodos de aprendizaje automático [12]. Por separado, los enfoques RUL basados en modelos pueden rendir mejor que los enfoques basados en datos cuando la degradación del sistema se modela con precisión [14]. Esta es una afirmación condicional, no una clasificación general: la ventaja de los métodos basados en modelos depende de cuán precisamente se modele la degradación.

Esa precisión tiene un costo. Los enfoques RUL basados en modelos requieren conocimiento a priori extenso del sistema y un modelo detallado, lo que puede implicar cálculos costosos [14]. Los modelos de batería basados en física requieren un equilibrio entre precisión y complejidad porque necesitan muchos parámetros, mientras que los modelos de aprendizaje automático requieren grandes conjuntos de datos de entrenamiento y pueden fallar al generalizar a escenarios no vistos [9]. Así que cada polo tiene un modo de falla distinto: los modelos físicos fallan cuando no se pueden obtener suficientes parámetros correctos, y los modelos ML fallan cuando no se pueden obtener suficientes datos representativos.

Del lado basado en datos, los métodos de pronóstico basados en datos usan reconocimiento de patrones para detectar cambios en los estados del sistema [14]. Los enfoques basados en datos generalmente requieren una cantidad sustancial de datos de entrenamiento y suelen producir intervalos de confianza más amplios que los enfoques basados en modelos [14]. Las artificial neural networks, support vector machines y Markov hidden chains se encuentran entre los algoritmos basados en datos usados para pronóstico [14]. Las artificial neural networks pueden modelar sistemas altamente no lineales, complejos y multidimensionales sin conocimiento previo del comportamiento del sistema [14], que es su principal atractivo, pero los enfoques de redes neuronales no proporcionan límites de confianza analíticos para predicciones RUL [14], que es su principal limitación para un despliegue relevante para la seguridad.

Un marco concreto basado en datos descrito en las fuentes combina un multi-layer perceptron con un algoritmo evolutivo que optimiza parámetros relacionados con los datos [14]. Esto ilustra una forma de abordar la falta de límites de confianza analíticos: buscar sobre parámetros relacionados con los datos en lugar de depender de una arquitectura fija. No restaura por sí mismo la incertidumbre calibrada; esa es una preocupación separada que se aborda a continuación mediante métodos de procesos gaussianos.

Los métodos informados por la física intentan mantener pequeño el requisito de datos incorporando física conocida en el proceso de aprendizaje. Un enfoque extrae parámetros correlacionados con el envejecimiento de una única curva de carga de batería con un modelo generalizable basado en física y suministra esos parámetros a una red neuronal profunda [3]. Otro integra la ecuación diferencial parcial de la ley de difusión de Fick's law desde un modelo de partícula única en el entrenamiento de la red neuronal para estimar el estado de carga y el estado de salud de la batería [9]. Un tercero combina una rama de red neuronal informada por solid-electrolyte-interphase construida a partir de capas de proyección lineal con física incorporada y una rama de red neuronal convolucional dilatada basada en datos específica de la tarea [4]. En cada caso la física restringe o suministra estructura para que la parte basada en datos necesite menos datos o menos grados de libertad.

Los procedimientos de entrenamiento difieren. El entrenamiento de SEI-DCN procede entrenando la rama basada en datos, entrenando la rama informada por la física para consistencia física sin actualizar los hiperparámetros de la rama basada en datos, y luego ajustando finamente ambas ramas simultáneamente [4]. Este procedimiento por etapas evita que las dos ramas interfieran entre sí antes de ser ajustadas conjuntamente. En contraste, el PINN de Fick's law coloca la restricción PDE directamente en la pérdida de entrenamiento de la red neuronal [9], y el método de curva de carga única alimenta parámetros físicos extraídos como características de entrada a una red profunda separada [3], lo cual es un acoplamiento más laxo que un término de pérdida incorporado.

Los resultados medidos son notables, pero cada uno proviene de su propio conjunto de datos y su propio conjunto de líneas base. Usando datos de un ciclo en tres tipos de batería y siete condiciones de operación, el método informado por la física logró un RMSE promedio de 11.42 ciclos y un MARE promedio de 3.19% [3]. El método informado por la física de curva de carga única redujo el RMSE en más del 45% y el MARE en 44% en relación con dos métodos basados en datos del estado del arte [3]. En el conjunto de datos Stanford-MIT-Toyota-battery, SEI-DCN fue diseñado para predecir RUL usando solo cuatro puntos de datos del ciclo de vida y se reportó que lograba una precisión de predicción muy alta [4]. Con datos de entrenamiento limitados, el PINN de Fick's law estimó el estado de carga con RMSE de 0.014% a 0.2% y el estado de salud con RMSE de 1.1% a 2.3% [9]. Estos tres resultados provienen de tres conjuntos de datos diferentes, tres métricas diferentes y diferentes líneas base de comparación, por lo que no se pueden clasificar entre sí directamente.

Lo que comparten es la motivación declarada para los modelos basados en física en general: los modelos de batería basados en física requieren un equilibrio entre precisión y complejidad porque necesitan muchos parámetros [9]. Cada uno de los tres métodos anteriores es una forma específica de reducir cuántos de esos parámetros deben aprenderse desde cero, ya sea extrayéndolos de una única curva, incorporando una PDE gobernante, o construyendo una rama física dedicada entrenada por separado antes de la fusión.

Una segunda familia trata los datos de ciclado como una secuencia o una imagen y aplica arquitecturas profundas comunes en otros dominios de series temporales. Una arquitectura CNN-LSTM con multi-head attention usa CNNs para extraer características locales, LSTMs para modelar tendencias a largo plazo, y atención para recalibrar la relevancia de las características a través de los pasos de tiempo [2]. Un enfoque relacionado pero distinto, CNN-LSTM-DRS, representa las entradas como imágenes en escala de grises de tamaño uniforme y usa selección dinámica de regresión para seleccionar submodelos de acuerdo con su rendimiento predictivo local [1]. Ambos combinan componentes convolucionales y recurrentes, pero el primero agrega atención sobre los pasos de tiempo mientras que el segundo agrega una representación de imagen más un mecanismo de selección de submodelos.

Sus evaluaciones son cada una comparaciones internas contra sus propios componentes más simples. Sobre secuencias de ventana deslizante normalizadas del NASA battery dataset, el híbrido CNN-LSTM-attention mejoró la precisión y robustez de predicción en relación con sus componentes individuales CNN y LSTM en experimentos Leave-One-Battery-Out y Temporal Split [2]. En el NASA battery dataset, CNN-LSTM-DRS superó a los modelos CNN y LSTM independientes en tamaños de datos de 60%, 70% y 80% [1]. Ambos usan el NASA battery dataset, así que en apariencia se ven comparables, pero las comparaciones reportadas son cada una contra las propias líneas base CNN y LSTM de ese artículo, no entre sí, y los protocolos experimentales difieren (Leave-One-Battery-Out y Temporal Split para el híbrido con atención, versus fracciones variables de tamaño de datos para DRS). Ninguna afirmación compara CNN-LSTM-attention directamente contra CNN-LSTM-DRS.

Un tercer enfoque de secuencia profunda toma prestado un modelo fundacional de series temporales preentrenado grande. El enfoque Lag-Llama RUL mejora la tokenización con análisis de autocorrelación, preentrena en el conjunto de datos RWTH Aachen University y ajusta finamente en conjuntos de datos específicos de destino CALCE, NASA, MIT y BAWAII [5]. Esto es arquitectónicamente diferente de los híbridos CNN-LSTM: se apoya en preentrenamiento en un conjunto de datos seguido de ajuste fino en varios otros, en lugar de entrenar una arquitectura a medida desde cero en un único conjunto de datos.

En relación con las líneas base, el Lag-Llama mejorado con autocorrelación redujo el MAE en 43.2% en CALCE, 55.2% en NASA, 78.9% en MIT y 91.1% en BAWAII [5]. Estos cuatro números provienen de cuatro conjuntos de datos de ajuste fino diferentes y deben leerse como cuatro resultados separados, no promediarse en un único número de titular, ya que el tamaño de la mejora varía en más de un factor de dos entre conjuntos de datos. Debido a que NASA también aparece como benchmark en las afirmaciones de CNN-LSTM, un lector podría sentirse tentado a comparar la reducción del 55.2% de MAE aquí contra los resultados de CNN-LSTM anteriores; las afirmaciones no reportan la misma métrica (reducción de MAE versus mejora de precisión/robustez) ni el mismo conjunto de líneas base, por lo que esa comparación no se puede hacer con la evidencia proporcionada.

La calibración, no solo la precisión puntual, es central para la pregunta de investigación, y los procesos gaussianos son la principal herramienta ofrecida aquí para ese propósito. La regresión de Gaussian process (GP) se puede usar para pronosticar el estado de salud de la batería a partir de conjuntos de datos de capacidad versus ciclo [13]. Los GPs son métodos Bayesian non-parametric que pueden modelar sistemas complejos mientras manejan la incertidumbre de manera fundamentada [13]. Esto aborda directamente la brecha de calibración que dejan los enfoques de redes neuronales, que no proporcionan límites de confianza analíticos [14].

La formulación GP descrita tiene dos características estructurales sobre las que vale la pena construir. Un GP puede incorporar información previa de degradación a través de una función media explícita cuando la forma funcional del modelo de degradación subyacente está disponible [13], lo cual es una forma natural de fusionar conocimiento físico con un modelo probabilístico basado en datos. Un GP de múltiples salidas puede explotar correlaciones entre datos de diferentes celdas [13], lo que permite que una flota de baterías comparta fuerza estadística en lugar de modelarse de forma independiente. El enfoque GP propuesto se demostró tanto para pronóstico a corto plazo como para pronóstico de vida útil restante a largo plazo en conjuntos de datos de capacidad versus ciclo de baterías de iones de litio [13].

Una línea de trabajo separada reemplaza la entrada de capacidad de ciclado con espectros de impedancia. Un modelo de Gaussian process predice RUL de batería directamente a partir de espectros completos de electrochemical impedance spectroscopy sin ingeniería de características adicional y determina automáticamente qué características espectrales predicen la degradación [7]. Esta es una modalidad de entrada diferente de las curvas de capacidad versus ciclo, por lo que no es directamente comparable con el trabajo de GP sobre capacidad anterior aunque ambos usen procesos gaussianos. El sistema Gaussian-process EIS predijo RUL incluso sin conocimiento completo de las condiciones de operación pasadas de una batería usando un conjunto de datos de más de 20,000 espectros EIS recogidos a través de diferentes estados de salud, estados de carga y temperaturas [7]. La escala de este conjunto de datos, más de 20,000 espectros, es notablemente mayor que las entradas de ciclo único o cuatro puntos usadas por los métodos informados por la física anteriores, lo que refleja un régimen de datos diferente.

Un método adicional apunta al pronóstico de salud usando características de procesamiento de señales en lugar de curvas crudas o espectros. El método RUL basado en SBPM combina sample entropy calculada a partir de secuencias de voltaje cortas con sparse Bayesian predictive modeling y bootstrap sampling [8]. Este es de nuevo un mecanismo distinto, usando entropía de ventanas de voltaje cortas como característica y un modelo predictivo Bayesian con remuestreo bootstrap para incertidumbre, en lugar de un kernel GP o una red neuronal. Ninguna afirmación reporta la precisión numérica de este método contra los otros enfoques descritos aquí, por lo que se puede listar como un mecanismo disponible pero no clasificar.

La respuesta institucional más clara a la fragmentación descrita anteriormente es un gran conjunto de datos integrado. BatteryLife integra 16 conjuntos de datos con baterías de 8 formatos, 59 sistemas químicos, 9 temperaturas de operación y 421 protocolos de carga/descarga [11]. BatteryLife contiene 2.5 veces el tamaño de muestra del anterior conjunto de datos de vida de batería más grande e incluye pruebas de laboratorio e industriales [11]. Esto aborda directamente la preocupación de generalización planteada antes: los conjuntos de datos de vida de batería existentes a menudo son pequeños y están restringidos a baterías de iones de litio de pequeña capacidad probadas bajo condiciones de laboratorio estrechas [11].

El propósito declarado es explícitamente benchmarking en lugar de un nuevo algoritmo. Los benchmarks inconsistentes y limitados hacen que la efectividad de las líneas base no sea clara y dejan incierto si los modelos populares en otros campos de series temporales son efectivos para Battery Life Prediction [11]. Esta afirmación es la evidencia más fuerte disponible de que la pregunta de investigación planteada aquí, qué familia gana en general, está actualmente abierta: el artículo que reunió el conjunto de datos más completo para responderla dice claramente que los benchmarks existentes no la resuelven.

Dado esto, cada número reportado en las tres secciones anteriores debe leerse como válido solo bajo su propio conjunto de datos y protocolo: secuencias de ventana deslizante de NASA con divisiones Leave-One-Battery-Out y Temporal Split para el híbrido con atención [2], NASA con fracciones variables de tamaño de datos para DRS [1], tres tipos de batería y siete condiciones de operación con un solo ciclo para las cifras de RMSE y MARE informadas por la física [3], el conjunto de datos Stanford-MIT-Toyota-battery con cuatro puntos del ciclo de vida para SEI-DCN [4], preentrenamiento RWTH Aachen con ajuste fino en CALCE, NASA, MIT y BAWAII para Lag-Llama [5], y más de 20,000 espectros EIS para el método de impedancia con Gaussian process [7]. Ninguna de estas seis configuraciones de evaluación se comparte en su totalidad entre dos artículos, por lo que ninguno de los números de precisión anteriores puede clasificarse legítimamente entre sí sin volver a ejecutar los métodos en un conjunto de datos común como BatteryLife.

Para un constructor, esto significa dos cosas. Primero, si el objetivo es publicar una comparación, el movimiento honesto es reimplementar múltiples métodos en un único conjunto de datos compartido (idealmente BatteryLife, dada su escala y diversidad) en lugar de citar el número autoinformado de cada artículo como si estuvieran en igualdad de condiciones. Segundo, si el objetivo es lanzar un pronosticador funcional rápidamente, la elección del método debe guiarse por qué datos están realmente disponibles (una única curva de carga, un puñado de ciclos tempranos, curvas completas de ciclo hasta falla, o espectros de impedancia) en lugar de por qué artículo reporta el número más bajo, ya que los números no están en igualdad de condiciones.

El límite central lo declaran las propias fuentes: los benchmarks inconsistentes y limitados hacen que la efectividad de las líneas base no sea clara y dejan incierto si los modelos populares en otros campos de series temporales son efectivos para Battery Life Prediction [11]. Ninguna afirmación de este conjunto reporta una ejecución cara a cara de métodos informados por la física, de regresión ML y de secuencia profunda en un único conjunto de datos compartido con un único protocolo compartido, por lo que la pregunta de investigación tal como se plantea (qué enfoque es más preciso y mejor calibrado en general) no se puede responder directamente con la evidencia; solo se puede responder método por método, conjunto de datos por conjunto de datos.

Un segundo límite se refiere específicamente a la calibración. Solo los métodos de Gaussian process [13][7] y la afirmación general sobre intervalos de confianza más amplios para enfoques basados en datos [14] hablan de calibración en absoluto. Ninguno de los artículos de secuencia profunda [1][2][5] ni los artículos informados por la física [3][4][9] reportan métricas de calibración (como cobertura de intervalos de predicción) en las afirmaciones dadas aquí, aunque varios reportan métricas de precisión puntual como reducción de RMSE, MARE o MAE. Una canalización que necesita intervalos RUL calibrados, por ejemplo para programación de mantenimiento, actualmente tiene el apoyo más fuerte de la literatura GP, no de los artículos de secuencia profunda o informados por la física citados.

Tercero, los métodos informados por la física que necesitan muy pocos datos (un ciclo [3], cuatro puntos del ciclo de vida [4]) se evalúan en familias de conjuntos de datos específicas (tres tipos de batería y siete condiciones de operación [3]; el conjunto de datos Stanford-MIT-Toyota-battery [4]) y estas afirmaciones no establecen si esa precisión con pocos datos se mantiene en las condiciones más heterogéneas representadas en BatteryLife (8 formatos, 59 sistemas químicos, 9 temperaturas de operación, 421 protocolos [11]). Extrapolar esos resultados de pocos datos a una flota con diferentes químicas o formatos sería una inferencia más allá de lo que apoyan las afirmaciones.

Finalmente, el equilibrio entre enfoques basados en modelos y basados en datos se declara solo condicionalmente: los enfoques basados en modelos pueden rendir mejor solo cuando la degradación del sistema se modela con precisión [14], y el modelado preciso requiere conocimiento a priori extenso y puede implicar cálculos costosos [14]. Si esa condición se puede cumplir de manera suficientemente barata para una química y formato de batería dados es una decisión de ingeniería, no algo resuelto por las afirmaciones aquí, y debe verificarse caso por caso en lugar de asumirse.

1. Elige primero el régimen de datos. Decide si el despliegue tiene historias completas de ciclo hasta falla (favoreciendo modelos de secuencia profunda como CNN-LSTM con atención [2] o CNN-LSTM-DRS [1]), solo un puñado de ciclos tempranos o una única curva de carga (favoreciendo el método de extracción informado por la física [3] o SEI-DCN [4]), espectros de impedancia (favoreciendo el método Gaussian-process EIS [7]), o una necesidad de pronósticos calibrados de horizonte largo a partir de curvas de capacidad-ciclo (favoreciendo la regresión GP [13]). Esta elección debe hacerse antes de cualquier modelado, ya que no se muestra que ninguno de los métodos aquí sea intercambiable entre regímenes de datos.
2. Obtén datos de BatteryLife cuando sea posible. BatteryLife integra 16 conjuntos de datos en 8 formatos, 59 sistemas químicos, 9 temperaturas de operación y 421 protocolos, con 2.5 veces el tamaño de muestra del conjunto de datos más grande anterior [11]. Usar esto en lugar de un único conjunto de datos estrecho aborda la preocupación de generalización de que los conjuntos de datos existentes a menudo son pequeños y están restringidos a condiciones de laboratorio estrechas [11].
3. Define el end-of-life y la etiqueta. Usa el umbral del 80% de la capacidad inicial para definir el end-of-life [11], y deriva las etiquetas RUL como ciclos restantes hasta ese umbral.
4. Construye los modelos de línea base antes del modelo objetivo. Para trabajo de secuencia profunda, primero entrena modelos CNN independientes y modelos LSTM independientes, ya que ambos híbridos citados reportan su ganancia en relación con estos componentes [2][1]. Para trabajo informado por la física, identifica dos métodos basados en datos del estado del arte para comparar, como lo hizo el método de curva de carga única [3].
5. Implementa la arquitectura elegida.

   if approach == "deep_sequence":
       build CNN feature extractor -> LSTM -> attention over time steps  # [2]
       or: build CNN feature extractor -> LSTM -> dynamic regression selection over submodels  # [1]
   elif approach == "physics_informed":
       extract ageing-correlated parameters from single charging curve using physics-based model  # [3]
       feed parameters into deep neural network  # [3]
       or: build SEI-informed branch (linear projection layers, embedded physics) + dilated CNN branch  # [4]
   elif approach == "gaussian_process":
       choose kernel (RBF + WhiteKernel; sklearn default is zero mean; add degradation-model mean if form is known)  # [13]
       fit GP on capacity-vs-cycle or EIS spectra  # [13][7]

6. Para SEI-DCN específicamente, sigue el orden de entrenamiento por etapas. Entrena la rama basada en datos primero, luego entrena la rama informada por la física para consistencia física sin actualizar los hiperparámetros de la rama basada en datos, luego ajusta finamente ambas ramas conjuntamente [4]. Omitir el orden por etapas elimina la separación en la que se basa el método para evitar que las dos ramas interfieran antes del ajuste conjunto.
7. Para el enfoque PINN, incorpora la ecuación gobernante directamente en la pérdida. Integra la PDE de Fick's law of diffusion desde un modelo de partícula única en el objetivo de entrenamiento de la red neuronal para estimar el estado de carga y el estado de salud conjuntamente [9]. Verifica que a la red no se le den más parámetros de los que requiere el equilibrio físico, ya que los modelos basados en física ya requieren muchos parámetros y agregar más derrota el propósito de reducir la necesidad de datos [9].
8. Si preentrenas un modelo fundacional, sigue la receta de dos etapas. Preentrena en el conjunto de datos RWTH Aachen University, mejora la tokenización con análisis de autocorrelación, luego ajusta finamente por separado en cada conjunto de datos objetivo (CALCE, NASA, MIT, BAWAII) [5]. Evalúa la reducción de MAE por separado por conjunto de datos de ajuste fino, ya que los cuatro conjuntos de datos mostraron diferentes magnitudes de mejora (43.2% a 91.1%) [5].
9. Evalúa con el mismo protocolo de división usado por el método citado más cercano. Para modelos de secuencia profunda basados en NASA, replica los experimentos Leave-One-Battery-Out y Temporal Split [2] o varía el tamaño de datos en 60%, 70%, 80% [1], dependiendo de qué método citado estés extendiendo. No compares tu número contra el número de otro artículo a menos que vuelvas a ejecutar ambos en la misma división.
10. Agrega una verificación de calibración. Si usas un GP, verifica que la función media codifique correctamente cualquier forma conocida del modelo de degradación [13] y comprueba si una formulación GP de múltiples salidas mejora los pronósticos al explotar correlaciones entre celdas [13]. Si usas una red neuronal, recuerda que no proporciona límites de confianza analíticos [14], así que reporta solo métricas de precisión puntual con honestidad en lugar de afirmar intervalos calibrados que no puede producir.
11. Reporta los puntos de falla explícitamente. Anota si los modos de degradación cambian (pérdida de material activo en cualquiera de los electrodos, o pérdida de inventario de litio [12]) de maneras que los datos de entrenamiento no cubrieron, y anota si el despliegue coincide con las condiciones de operación (temperatura, protocolo) que cubre el conjunto de datos elegido, ya que las condiciones de laboratorio estrechas fueron señaladas como un riesgo de generalización [11].

El script a continuación construye una canalización RUL pequeña y reproducible sobre el propio esquema SQLite del proyecto. Lee barras diarias de la tabla bars (tf='1d'), trata close como un proxy de la fracción de capacidad de batería del valor inicial (una señal de reemplazo ya que el esquema no tiene campos específicos de batería), y define end-of-life como el punto en que esta señal normalizada cae al 80% de su valor inicial, siguiendo la definición de end-of-life del 80% de la capacidad inicial [11]. Luego implementa tres líneas base que son fieles a los mecanismos citados a una escala reproducible y CPU-light: (1) un regresor de Gaussian process con kernels RBF y white-noise y la media cero predeterminada de sklearn, una línea base GP estándar que se puede extender con una función media de degradación explícita cuando la forma funcional se conoce [13]; (2) un regresor de secuencia estilo CNN-LSTM pequeño (implementado con bloques de construcción numpy/sklearn simples que representan las etapas de características CNN y LSTM) como línea base basada en datos, siguiendo la estructura CNN-then-LSTM [2][1]; y (3) una característica simple de sample entropy más regresión ridge Bayesian lineal, siguiendo la idea de sample entropy más modelado predictivo Bayesian [8]. El script evalúa el RMSE de RUL predicho (en pasos de tiempo) para cada método en una porción reservada de la serie de cada símbolo, calcula la cobertura del intervalo de predicción del 95% del GP, e imprime una tabla de comparación. Debido a que la ejecución usa precios de cierre diarios de AAPL/MSFT/BTC-USD que nunca cruzan el umbral del 80%, find_eol_index devuelve la longitud de la serie y los valores de RMSE (~286 pasos) no llevan información sobre la precisión de RUL; la tabla demuestra que la canalización se ejecuta de extremo a extremo pero no constituye una comparación de métodos. La cobertura medida del GP es aproximadamente 0.16, muy por debajo del objetivo nominal de 0.95, lo que muestra que el kernel y los hiperparámetros de la línea base necesitan ajuste antes de que el arnés pueda servir como benchmark de calibración. Todo es determinista y se ejecuta sin acceso a red en bastante menos de tres minutos en CPU para tamaños típicos de la tabla bars.

import os, sys, time, sqlite3, math
import numpy as np
import pandas as pd
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel, ConstantKernel
from sklearn.linear_model import BayesianRidge
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split

# ---------------------------------------------------------------------
# Data loading
# ---------------------------------------------------------------------

def load_bars(db_path):
    """Load daily bars from the project's sqlite schema.
    Input: path to data.sqlite. Output: dict symbol -> DataFrame sorted by ts.
    Check: printed row counts per symbol should be > 30 for the pipeline to be meaningful.
    """
    con = sqlite3.connect(db_path)
    df = pd.read_sql_query(
        "select symbol, ts, close from bars where tf = '1d' order by symbol, ts", con
    )
    con.close()
    out = {}
    for sym, g in df.groupby("symbol"):
        g = g.reset_index(drop=True)
        out[sym] = g
    return out


def make_synthetic_bars(n_symbols=3, n_points=200, seed=0):
    """Fallback data generator used only if data.sqlite has no bars.
    Produces a decaying-capacity-like curve with noise, so the pipeline is
    still runnable and checkable end to end.
    """
    rng = np.random.default_rng(seed)
    out = {}
    for i in range(n_symbols):
        sym = f"SIM{i}"
        t = np.arange(n_points)
        decay = 1.0 - 0.002 * t - 0.000015 * (t ** 1.6)
        noise = rng.normal(0, 0.004, size=n_points)
        close = decay + noise
        ts = pd.date_range("2020-01-01", periods=n_points, freq="D").astype(str)
        out[sym] = pd.DataFrame({"symbol": sym, "ts": ts, "close": close})
    return out


# ---------------------------------------------------------------------
# End-of-life / RUL labels
# implements CLAIM A: end-of-life at 80% of initial capacity [11]
# ---------------------------------------------------------------------

def normalize_capacity(series):
    s = series.values.astype(float)
    s0 = s[0] if s[0] != 0 else 1.0
    return s / s0


def find_eol_index(norm_capacity, threshold=0.8):
    below = np.where(norm_capacity < threshold)[0]
    return below[0] if len(below) > 0 else len(norm_capacity)


def build_rul_labels(norm_capacity, eol_index):
    n = len(norm_capacity)
    rul = np.zeros(n)
    for i in range(n):
        rul[i] = max(eol_index - i, 0)
    return rul


# ---------------------------------------------------------------------
# Sample entropy feature [8]
# ---------------------------------------------------------------------

def sample_entropy(x, m=2, r=0.2):
    n = len(x)
    if n < m + 2:
        return 0.0
    x = (x - np.mean(x)) / (np.std(x) + 1e-9)
    r = r * np.std(x) if np.std(x) > 0 else 0.01

    def _phi(m):
        count = 0
        templates = np.array([x[i:i + m] for i in range(n - m + 1)])
        for i in range(len(templates)):
            dist = np.max(np.abs(templates - templates[i]), axis=1)
            count += np.sum(dist < r)
        count -= len(templates)
        return count

    A = _phi(m + 1)
    B = _phi(m)
    if A == 0 or B == 0:
        return 0.0
    return -np.log(A / B)


# ---------------------------------------------------------------------
# Baseline 1: GP with RBF+WhiteKernel, zero mean [13]
# ---------------------------------------------------------------------

def fit_gp_baseline(X, y):
    if len(X) < 3:
        return None
    kernel = ConstantKernel(1.0) * RBF(length_scale=10.0) + WhiteKernel(noise_level=1.0)
    gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=2, random_state=0)
    gp.fit(X, y)
    return gp


# ---------------------------------------------------------------------
# Baseline 2: CNN-LSTM-style local+trend regressor [2][1]
# ---------------------------------------------------------------------

def fit_cnn_lstm_style(X, y):
    if len(X) < 3:
        return None
    mlp = MLPRegressor(
        hidden_layer_sizes=(32, 16),
        activation="relu",
        solver="adam",
        max_iter=200,
        random_state=0,
        early_stopping=False
    )
    mlp.fit(X, y)
    return mlp


# ---------------------------------------------------------------------
# Baseline 3: Sample-entropy + Bayesian ridge [8]
# ---------------------------------------------------------------------

def fit_sbpm_style(X_raw, y, window=10):
    if len(X_raw) < 3:
        return None, None
    features = []
    for i in range(len(X_raw)):
        start = max(0, i - window + 1)
        segment = X_raw[start:i+1, 0]
        se = sample_entropy(segment, m=2, r=0.2)
        features.append([se])
    features = np.array(features)
    br = BayesianRidge()
    br.fit(features, y)
    return br, window


# ---------------------------------------------------------------------
# Pipeline orchestration
# ---------------------------------------------------------------------

def run_pipeline(bars_by_symbol, window=30, test_size=0.3):
    results = []
    for sym, df in bars_by_symbol.items():
        if len(df) < window + 10:
            continue
        norm_cap = normalize_capacity(df["close"])
        eol_idx = find_eol_index(norm_cap, threshold=0.8)
        rul = build_rul_labels(norm_cap, eol_idx)
        
        X = []
        y_rul = []
        for i in range(window, len(df)):
            seg = norm_cap[i - window:i]
            X.append(seg)
            y_rul.append(rul[i])
        X = np.array(X)
        y_rul = np.array(y_rul)
        
        if len(X) < 10:
            continue
        
        X_train, X_test, y_train, y_test = train_test_split(
            X, y_rul, test_size=test_size, shuffle=False
        )
        
        rmse_gp = np.nan
        gp = fit_gp_baseline(X_train, y_train)
        if gp is not None:
            y_pred, y_std = gp.predict(X_test, return_std=True)
            rmse_gp = np.sqrt(np.mean((y_test - y_pred) ** 2))
            lower = y_pred - 1.96 * y_std
            upper = y_pred + 1.96 * y_std
            coverage = np.mean((y_test >= lower) & (y_test <= upper))
        else:
            coverage = np.nan
        
        rmse_cnn_lstm = np.nan
        mlp = fit_cnn_lstm_style(X_train, y_train)
        if mlp is not None:
            y_pred = mlp.predict(X_test)
            rmse_cnn_lstm = np.sqrt(np.mean((y_test - y_pred) ** 2))
        
        rmse_sbpm = np.nan
        br, win = fit_sbpm_style(X_train, y_train, window=10)
        if br is not None:
            features_test = []
            for i in range(len(X_test)):
                start = max(0, i - win + 1)
                segment = X_test[start:i+1, 0] if i > 0 else X_test[0:1, 0]
                se = sample_entropy(segment, m=2, r=0.2)
                features_test.append([se])
            features_test = np.array(features_test)
            y_pred = br.predict(features_test)
            rmse_sbpm = np.sqrt(np.mean((y_test - y_pred) ** 2))
        
        results.append({
            "symbol": sym,
            "rmse_gp": rmse_gp,
            "gp_95_coverage": coverage,
            "rmse_cnn_lstm_style": rmse_cnn_lstm,
            "rmse_sbpm_style": rmse_sbpm
        })
    
    return pd.DataFrame(results)


# ---------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------

if __name__ == "__main__":
    t0 = time.time()
    db_path = "data.sqlite"
    bars_by_symbol = {}
    if os.path.exists(db_path):
        bars_by_symbol = load_bars(db_path)
        bars_by_symbol = {k: v for k, v in bars_by_symbol.items() if len(v) > 40}
    if not bars_by_symbol:
        print("No usable bars found in", db_path, "- using synthetic fallback data.")
        bars_by_symbol = make_synthetic_bars()

    results = run_pipeline(bars_by_symbol)

    if results.empty:
        print("No results produced: input series too short for the chosen window.")
        sys.exit(0)

    print("\nPer-symbol RUL RMSE (time steps), threshold = 80% of initial value [11]:")
    print(results.to_string(index=False))

    print("\nMean RMSE across symbols (methods not comparable: EOL threshold not reached):")
    print("  GP baseline (RBF+White, zero mean) [13]:     %.4f" % results["rmse_gp"].mean())
    print("  GP 95%% interval coverage:                    %.2f" % results["gp_95_coverage"].mean())
    print("  CNN-LSTM-style local+trend regressor [2][1]: %.4f" % results["rmse_cnn_lstm_style"].mean())
    print("  Sample-entropy + Bayesian ridge [8]:         %.4f" % results["rmse_sbpm_style"].mean())
    print("\nNote: daily close prices do not cross 80%% threshold; RMSE reflects series length, not RUL accuracy.")
    print("Elapsed seconds: %.1f" % (time.time() - t0))