Prévision de la dégradation des batteries : quels modèles ouverts prédisent la durée de vie utile restante à partir des données de cyclage ?

Les batteries sont généralement considérées en fin de vie lorsque leur capacité chute à 80% de la capacité initiale [11]. Atteindre ce point prend beaucoup de temps dans des conditions de test : les tests de dégradation des batteries sont chronophages car la perte de capacité non linéaire survient sur des mois à des années avant la fin de vie [11]. Cela signifie que tout modèle RUL qui nécessite des données de cyclage complètes pour l'entraînement est coûteux à construire et lent à valider, ce qui motive des méthodes qui n'ont besoin que de quelques cycles précoces ou d'une seule courbe de charge.

La dégradation elle-même n'est pas un processus unique. Les modes de dégradation de batterie couramment rapportés incluent la perte de matériaux actifs sur l'électrode positive, la perte de matériaux actifs sur l'électrode négative, et la perte d'inventaire de lithium [12]. Comme ces modes peuvent se combiner différemment selon les chimies, les formats et les conditions de fonctionnement, un modèle entraîné sur un cadre étroit peut ne pas se transférer à un autre. C'est exactement la préoccupation de généralisabilité soulevée à propos des jeux de données existants.

Les jeux de données existants sur la durée de vie des batteries sont souvent petits et restreints à des batteries lithium-ion de petite capacité testées dans des conditions de laboratoire étroites, ce qui soulève des préoccupations de généralisabilité [11]. Des benchmarks incohérents et limités rendent l'efficacité des baselines incertaine et laissent indéterminé si les modèles populaires dans d'autres domaines de séries temporelles sont efficaces pour la prédiction de la durée de vie des batteries [11]. Donc la question que le lecteur pose, quelle famille de modélisation gagne, n'est actuellement pas répondable à partir d'une seule étude contrôlée ; elle n'est répondable que pièce par pièce, une comparaison propre à un article à la fois.

Cela importe pour un constructeur car le bon choix d'ingénierie dépend de ce qui est disponible : un modèle physique fin de la cellule, un grand jeu de données étiquetées de durée de vie complète en cycles, ou seulement une poignée de mesures de début de vie. Les sections ci-dessous détaillent ce qu'est réellement chaque famille de méthodes, comment chacune fonctionne mécaniquement, ce que chacune a mesuré et contre quelle baseline, puis donnent une procédure concrète et du code pour construire un pipeline défendable.

Deux grandes familles sont directement contrastées dans les sources. La capacité et la résistance en ligne d'une batterie peuvent être prédites à l'aide de modèles algébriques d'ordre réduit, d'observateurs d'état tels que les filtres de Kalman étendus et les filtres à particules couplés à des modèles de circuit équivalent ou électrochimiques, et de méthodes d'apprentissage automatique [12]. Séparément, les approches RUL basées sur modèle peuvent être plus performantes que les approches pilotées par les données lorsque la dégradation du système est modélisée avec précision [14]. C'est une affirmation conditionnelle, pas un classement général : l'avantage des méthodes basées sur modèle dépend de la précision avec laquelle la dégradation est modélisée.

Cette précision a un coût. Les approches RUL basées sur modèle nécessitent une connaissance a priori étendue du système et un modèle fin, ce qui peut impliquer des calculs coûteux [14]. Les modèles de batterie basés sur la physique nécessitent un compromis entre précision et complexité car ils requièrent de nombreux paramètres, tandis que les modèles d'apprentissage automatique nécessitent de grands jeux de données d'entraînement et peuvent échouer à généraliser à des scénarios non vus [9]. Ainsi chaque pôle a un mode de défaillance distinct : les modèles physiques échouent quand vous ne pouvez pas obtenir assez de paramètres corrects, et les modèles ML échouent quand vous ne pouvez pas obtenir assez de données représentatives.

Du côté piloté par les données, les méthodes de pronostic pilotées par les données utilisent la reconnaissance de motifs pour détecter les changements dans les états du système [14]. Les approches pilotées par les données nécessitent généralement une quantité substantielle de données d'entraînement et produisent habituellement des intervalles de confiance plus larges que les approches basées sur modèle [14]. Les réseaux de neurones artificiels, les machines à vecteurs de support et les chaînes de Markov cachées font partie des algorithmes pilotés par les données utilisés pour le pronostic [14]. Les réseaux de neurones artificiels peuvent modéliser des systèmes hautement non linéaires, complexes et multidimensionnels sans connaissance préalable du comportement du système [14], ce qui est leur principal attrait, mais les approches par réseau de neurones ne fournissent pas de limites de confiance analytiques pour les prédictions RUL [14], ce qui est leur principale limitation pour un déploiement lié à la sécurité.

Un cadre concret piloté par les données décrit dans les sources combine un perceptron multicouche avec un algorithme évolutionnaire qui optimise des paramètres liés aux données [14]. Cela illustre une façon de remédier à l'absence de limites de confiance analytiques : rechercher sur les paramètres liés aux données plutôt que de s'appuyer sur une architecture fixe. Cela ne restaure pas en soi une incertitude calibrée ; c'est une préoccupation distincte traitée ci-dessous par les méthodes de processus gaussiens.

Les méthodes informées par la physique tentent de maintenir la exigence de données faible en intégrant la physique connue dans le processus d'apprentissage. Une approche extrait des paramètres corrélés au vieillissement à partir d'une seule courbe de charge de batterie avec un modèle basé sur la physique généralisable et fournit ces paramètres à un réseau de neurones profond [3]. Une autre intègre l'équation aux dérivées partielles de la loi de diffusion de Fick issue d'un modèle à particule unique dans l'entraînement du réseau de neurones pour estimer l'état de charge et l'état de santé de la batterie [9]. Une troisième combine une branche de réseau de neurones informée par l'interphase solide-électrolyte, construite à partir de couches de projection linéaire avec physique intégrée, et une branche de réseau de neurones convolutif dilaté pilotée par les données spécifique à la tâche [4]. Dans chaque cas, la physique contraint ou fournit la structure de sorte que la partie pilotée par les données nécessite moins de données ou moins de degrés de liberté.

Les procédures d'entraînement diffèrent. L'entraînement de SEI-DCN procède en entraînant la branche pilotée par les données, en entraînant la branche informée par la physique pour la cohérence physique sans mettre à jour les hyperparamètres de la branche pilotée par les données, puis en affinant les deux branches simultanément [4]. Cette procédure par étapes empêche les deux branches d'interférer entre elles avant leur réglage conjoint. En revanche, le PINN basé sur la loi de Fick place la contrainte PDE directement dans la perte d'entraînement du réseau de neurones [9], et la méthode à courbe de charge unique fournit les paramètres physiques extraits comme caractéristiques d'entrée à un réseau profond séparé [3], ce qui est un couplage plus lâche qu'un terme de perte intégré.

Les résultats mesurés sont notables mais chacun provient de son propre jeu de données et de son propre ensemble de baselines. En utilisant les données d'un cycle sur trois types de batteries et sept conditions de fonctionnement, la méthode informée par la physique a atteint un RMSE moyen de 11.42 cycles et un MARE moyen de 3.19% [3]. La méthode informée par la physique à courbe de charge unique a réduit le RMSE de plus de 45% et le MARE de 44% par rapport à deux méthodes pilotées par les données de l'état de l'art [3]. Sur le jeu de données Stanford-MIT-Toyota-battery, SEI-DCN a été conçu pour prédire la RUL en utilisant seulement quatre points de données de cycle de vie et a été rapporté comme atteignant une très haute précision de prédiction [4]. Avec des données d'entraînement limitées, le PINN basé sur la loi de Fick a estimé l'état de charge avec un RMSE de 0.014% à 0.2% et l'état de santé avec un RMSE de 1.1% à 2.3% [9]. Ces trois résultats proviennent de trois jeux de données différents, trois métriques différentes et des baselines de comparaison différentes, donc ils ne peuvent pas être classés directement les uns contre les autres.

Ce qu'ils partagent, c'est la motivation énoncée pour les modèles basés sur la physique en général : les modèles de batterie basés sur la physique nécessitent un compromis entre précision et complexité car ils requièrent de nombreux paramètres [9]. Chacune des trois méthodes ci-dessus est une façon spécifique de réduire combien de ces paramètres doivent être appris à partir de zéro, soit en les extrayant d'une seule courbe, soit en intégrant une PDE gouvernante, soit en construisant une branche physique dédiée entraînée séparément avant la fusion.

Une deuxième famille traite les données de cyclage comme une séquence ou une image et applique des architectures profondes courantes dans d'autres domaines de séries temporelles. Une architecture CNN-LSTM avec attention multi-têtes utilise des CNNs pour extraire des caractéristiques locales, des LSTMs pour modéliser les tendances à long terme, et l'attention pour recalibrer la pertinence des caractéristiques à travers les pas de temps [2]. Une approche connexe mais distincte, CNN-LSTM-DRS, représente les entrées comme des images en niveaux de gris de taille uniforme et utilise une sélection dynamique de régression pour choisir des sous-modèles selon leur performance prédictive locale [1]. Les deux combinent des composants convolutifs et récurrents, mais la première ajoute l'attention sur les pas de temps tandis que la seconde ajoute une représentation en image plus un mécanisme de sélection de sous-modèles.

Leurs évaluations sont chacune des comparaisons internes contre leurs propres composants plus simples. Sur des séquences à fenêtre glissante normalisées issues du jeu de données NASA battery, l'hybride CNN-LSTM-attention a amélioré la précision et la robustesse de prédiction par rapport à ses composants CNN et LSTM individuels dans des expériences Leave-One-Battery-Out et Temporal Split [2]. Sur le jeu de données NASA battery, CNN-LSTM-DRS a surpassé les modèles CNN et LSTM autonomes pour des tailles de données de 60%, 70% et 80% [1]. Les deux utilisent le jeu de données NASA battery, donc en apparence ils semblent comparables, mais les comparaisons rapportées sont chacune contre les propres baselines CNN et LSTM de cet article, pas l'un contre l'autre, et les protocoles expérimentaux diffèrent (Leave-One-Battery-Out et Temporal Split pour l'hybride à attention, contre des fractions de taille de données variables pour DRS). Aucune affirmation ne compare CNN-LSTM-attention directement à CNN-LSTM-DRS.

Une troisième approche de séquence profonde emprunte un grand modèle de fondation de séries temporelles pré-entraîné. L'approche Lag-Llama RUL améliore la tokenisation avec une analyse d'autocorrélation, se pré-entraîne sur le jeu de données RWTH Aachen University, et s'affine sur les jeux de données cibles spécifiques CALCE, NASA, MIT et BAWAII [5]. Cela est architecturalement différent des hybrides CNN-LSTM : cela repose sur un pré-entraînement sur un jeu de données suivi d'un affinage sur plusieurs autres, plutôt que d'entraîner une architecture sur mesure à partir de zéro sur un seul jeu de données.

Par rapport aux baselines, le Lag-Llama amélioré par autocorrélation a réduit le MAE de 43.2% sur CALCE, 55.2% sur NASA, 78.9% sur MIT et 91.1% sur BAWAII [5]. Ces quatre nombres proviennent de quatre jeux de données d'affinage différents et doivent être lus comme quatre résultats séparés, pas moyennés en un seul chiffre phare, puisque l'ampleur de l'amélioration varie de plus d'un facteur deux selon les jeux de données. Comme NASA apparaît aussi comme benchmark dans les affirmations CNN-LSTM, un lecteur pourrait être tenté de comparer la réduction de MAE de 55.2% ici aux résultats CNN-LSTM ci-dessus ; les affirmations ne rapportent pas la même métrique (réduction de MAE contre amélioration de précision/robustesse) ni le même ensemble de baselines, donc cette comparaison ne peut pas être faite à partir des preuves données.

La calibration, et pas seulement la précision ponctuelle, est centrale à la question de recherche, et les processus gaussiens sont le principal outil offert ici à cette fin. La régression par processus gaussien (GP) peut être utilisée pour prévoir l'état de santé d'une batterie à partir de jeux de données capacité-versus-cycle [13]. Les GPs sont des méthodes bayésiennes non paramétriques qui peuvent modéliser des systèmes complexes tout en gérant l'incertitude de manière fondée [13]. Cela cible directement la lacune de calibration laissée par les approches par réseau de neurones, qui ne fournissent pas de limites de confiance analytiques [14].

La formulation GP décrite a deux caractéristiques structurelles sur lesquelles s'appuyer. Un GP peut incorporer des informations de dégradation a priori via une fonction moyenne explicite lorsque la forme fonctionnelle du modèle de dégradation sous-jacent est disponible [13], ce qui est une façon naturelle de fusionner la connaissance physique avec un modèle probabiliste piloté par les données. Un GP à sorties multiples peut exploiter les corrélations entre les données de différentes cellules [13], ce qui permet à une flotte de batteries de partager une force statistique plutôt que d'être modélisée indépendamment. L'approche GP proposée a été démontrée à la fois pour la prévision à court terme et la prévision à long terme de la durée de vie utile restante sur des jeux de données de capacité-versus-cycle de batteries lithium-ion [13].

Une ligne de travail séparée remplace l'entrée capacité-de-cyclage par des spectres d'impédance. Un modèle de processus gaussien prédit la RUL d'une batterie directement à partir de spectres complets de spectroscopie d'impédance électrochimique sans ingénierie de caractéristiques supplémentaire et détermine automatiquement quelles caractéristiques spectrales prédisent la dégradation [7]. C'est une modalité d'entrée différente des courbes capacité-versus-cycle, donc ce n'est pas directement comparable au travail GP-sur-capacité ci-dessus même si les deux utilisent des processus gaussiens. Le système GP EIS a prédit la RUL même sans connaissance complète des conditions de fonctionnement passées d'une batterie en utilisant un jeu de données de plus de 20,000 spectres EIS collectés à travers différents états de santé, états de charge et températures [7]. L'échelle de ce jeu de données, plus de 20,000 spectres, est nettement plus grande que les entrées à cycle unique ou à quatre points utilisées par les méthodes informées par la physique ci-dessus, reflétant un régime de données différent.

Une autre méthode cible le pronostic de santé en utilisant des caractéristiques de traitement du signal plutôt que des courbes brutes ou des spectres. La méthode RUL basée sur SBPM combine l'entropie d'échantillon calculée à partir de courtes séquences de tension avec une modélisation prédictive bayésienne sparse et un échantillonnage bootstrap [8]. C'est là encore un mécanisme distinct, utilisant l'entropie de courtes fenêtres de tension comme caractéristique et un modèle prédictif bayésien avec rééchantillonnage bootstrap pour l'incertitude, plutôt qu'un noyau GP ou un réseau de neurones. Aucune affirmation ne rapporte la précision numérique de cette méthode par rapport aux autres approches décrites ici, donc elle peut être listée comme un mécanisme disponible mais non classée.

La réponse institutionnelle la plus claire à la fragmentation décrite ci-dessus est un grand jeu de données intégré. BatteryLife intègre 16 jeux de données avec des batteries de 8 formats, 59 systèmes chimiques, 9 températures de fonctionnement et 421 protocoles de charge/décharge [11]. BatteryLife contient 2.5 fois la taille d'échantillon du précédent plus grand jeu de données sur la durée de vie des batteries et inclut des tests de laboratoire et industriels [11]. Cela cible directement la préoccupation de généralisabilité soulevée plus tôt : les jeux de données existants sur la durée de vie des batteries sont souvent petits et restreints à des batteries lithium-ion de petite capacité testées dans des conditions de laboratoire étroites [11].

Le but énoncé est explicitement le benchmarking plutôt qu'un nouvel algorithme. Des benchmarks incohérents et limités rendent l'efficacité des baselines incertaine et laissent indéterminé si les modèles populaires dans d'autres domaines de séries temporelles sont efficaces pour la prédiction de la durée de vie des batteries [11]. Cette affirmation est la preuve la plus forte disponible que la question de recherche posée ici, quelle famille gagne globalement, est actuellement ouverte : l'article qui a assemblé le jeu de données le plus complet pour y répondre dit clairement que les benchmarks existants ne la tranchent pas.

Compte tenu de cela, chaque nombre rapporté dans les trois sections précédentes doit être lu comme valide uniquement dans son propre jeu de données et protocole : séquences NASA à fenêtre glissante avec découpages Leave-One-Battery-Out et Temporal Split pour l'hybride à attention [2], NASA avec fractions de taille de données variables pour DRS [1], trois types de batteries et sept conditions de fonctionnement avec un cycle unique pour les chiffres de RMSE et MARE informés par la physique [3], le jeu de données Stanford-MIT-Toyota-battery avec quatre points de cycle de vie pour SEI-DCN [4], pré-entraînement RWTH Aachen avec affinage CALCE, NASA, MIT et BAWAII pour Lag-Llama [5], et plus de 20,000 spectres EIS pour la méthode d'impédance par processus gaussien [7]. Aucun de ces six dispositifs d'évaluation n'est partagé intégralement entre deux articles, donc aucun des nombres de précision ci-dessus ne peut être légitimement classé contre un autre sans réexécuter les méthodes sur un jeu de données commun tel que BatteryLife.

Pour un constructeur cela signifie deux choses. Premièrement, si l'objectif est de publier une comparaison, la démarche honnête est de réimplémenter plusieurs méthodes sur un seul jeu de données partagé (idéalement BatteryLife, vu son échelle et sa diversité) plutôt que de citer le nombre auto-rapporté de chaque article comme s'ils étaient sur un pied d'égalité. Deuxièmement, si l'objectif est de livrer rapidement un prévisionniste fonctionnel, le choix de la méthode devrait être guidé par les données réellement disponibles (une seule courbe de charge, une poignée de cycles précoces, des courbes complètes jusqu'à défaillance, ou des spectres d'impédance) plutôt que par l'article qui rapporte le nombre le plus bas, puisque les nombres ne sont pas sur un terrain de jeu égal.

La limite centrale est énoncée par les sources elles-mêmes : des benchmarks incohérents et limités rendent l'efficacité des baselines incertaine et laissent indéterminé si les modèles populaires dans d'autres domaines de séries temporelles sont efficaces pour la prédiction de la durée de vie des batteries [11]. Aucune affirmation de cet ensemble ne rapporte une exécution directe de méthodes informées par la physique, de régression ML et de séquences profondes sur un seul jeu de données partagé avec un seul protocole partagé, donc la question de recherche telle que posée (quelle approche est globalement la plus précise et la mieux calibrée) ne peut pas être répondue directement à partir des preuves ; elle ne peut être répondue que méthode par méthode, jeu de données par jeu de données.

Une deuxième limite concerne spécifiquement la calibration. Seules les méthodes de processus gaussiens [13][7] et l'affirmation générale sur des intervalles de confiance plus larges pour les approches pilotées par les données [14] traitent de la calibration. Aucun des articles sur les séquences profondes [1][2][5] ni les articles informés par la physique [3][4][9] ne rapporte de métriques de calibration (telles que la couverture des intervalles de prédiction) dans les affirmations données ici, même si plusieurs rapportent des métriques de précision ponctuelle comme le RMSE, le MARE ou la réduction de MAE. Un pipeline qui nécessite des intervalles RUL calibrés, par exemple pour la planification de maintenance, a actuellement le plus fort soutien de la littérature GP, pas des articles de séquences profondes ou informés par la physique cités.

Troisièmement, les méthodes informées par la physique qui nécessitent très peu de données (un cycle [3], quatre points de cycle de vie [4]) sont évaluées sur des familles de jeux de données spécifiques (trois types de batteries et sept conditions de fonctionnement [3] ; le jeu de données Stanford-MIT-Toyota-battery [4]) et il n'est pas établi par ces affirmations si cette précision à faibles données tient sur les conditions plus hétérogènes représentées dans BatteryLife (8 formats, 59 systèmes chimiques, 9 températures de fonctionnement, 421 protocoles [11]). Extrapoler ces résultats à faibles données à une flotte avec des chimies ou formats différents serait une inférence au-delà de ce que les affirmations soutiennent.

Enfin, le compromis entre approches basées sur modèle et pilotées par les données n'est énoncé que conditionnellement : les approches basées sur modèle peuvent être plus performantes uniquement lorsque la dégradation du système est modélisée avec précision [14], et une modélisation précise nécessite une connaissance a priori étendue et peut impliquer des calculs coûteux [14]. Savoir si cette condition peut être satisfaite à un coût suffisamment faible pour une chimie et un format de batterie donnés est un jugement d'ingénierie, pas quelque chose de tranché par les affirmations ici, et cela devrait être vérifié au cas par cas plutôt que supposé.

1. Choisissez d'abord le régime de données. Décidez si le déploiement dispose d'historiques complets de cycle jusqu'à défaillance (favorisant les modèles de séquences profondes tels que CNN-LSTM avec attention [2] ou CNN-LSTM-DRS [1]), seulement une poignée de cycles précoces ou une seule courbe de charge (favorisant la méthode d'extraction informée par la physique [3] ou SEI-DCN [4]), des spectres d'impédance (favorisant la méthode GP EIS [7]), ou un besoin de prévisions calibrées à long horizon à partir de courbes capacité-cycle (favorisant la régression GP [13]). Ce choix doit être fait avant toute modélisation, car aucune des méthodes ici n'est démontrée interchangeable entre régimes de données.
2. Sourcez les données depuis BatteryLife lorsque c'est possible. BatteryLife intègre 16 jeux de données à travers 8 formats, 59 systèmes chimiques, 9 températures de fonctionnement et 421 protocoles, avec 2.5 fois la taille d'échantillon du précédent plus grand jeu de données [11]. L'utiliser plutôt qu'un seul jeu de données étroit répond à la préoccupation de généralisabilité selon laquelle les jeux de données existants sont souvent petits et restreints à des conditions de laboratoire étroites [11].
3. Définissez la fin de vie et l'étiquette. Utilisez le seuil de 80% de la capacité initiale pour définir la fin de vie [11], et dérivez les étiquettes RUL comme les cycles restants jusqu'à ce seuil.
4. Construisez les modèles baselines avant le modèle cible. Pour le travail sur les séquences profondes, entraînez d'abord des modèles CNN autonomes et LSTM autonomes, puisque les deux hybrides cités rapportent leur gain par rapport à ces composants [2][1]. Pour le travail informé par la physique, identifiez deux méthodes pilotées par les données de l'état de l'art pour comparer, comme l'a fait la méthode à courbe de charge unique [3].
5. Implémentez l'architecture choisie.

   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. Pour SEI-DCN spécifiquement, suivez l'ordre d'entraînement par étapes. Entraînez d'abord la branche pilotée par les données, puis entraînez la branche informée par la physique pour la cohérence physique sans mettre à jour les hyperparamètres de la branche pilotée par les données, puis affinez les deux branches conjointement [4]. Sauter l'ordre par étapes supprime la séparation sur laquelle la méthode repose pour empêcher les deux branches d'interférer avant le réglage conjoint.
7. Pour l'approche PINN, intégrez l'équation gouvernante directement dans la perte. Intégrez la PDE de la loi de diffusion de Fick issue d'un modèle à particule unique dans l'objectif d'entraînement du réseau de neurones pour estimer conjointement l'état de charge et l'état de santé [9]. Vérifiez que le réseau ne reçoit pas plus de paramètres que ne l'exige le compromis physique, puisque les modèles basés sur la physique nécessitent déjà de nombreux paramètres et en ajouter davantage va à l'encontre du but de réduire le besoin de données [9].
8. Si vous pré-entraînez un modèle de fondation, suivez la recette en deux étapes. Pré-entraînez sur le jeu de données RWTH Aachen University, améliorez la tokenisation avec une analyse d'autocorrélation, puis affinez séparément sur chaque jeu de données cible (CALCE, NASA, MIT, BAWAII) [5]. Évaluez la réduction de MAE séparément par jeu de données d'affinage, puisque les quatre jeux de données ont montré des ampleurs d'amélioration différentes (43.2% à 91.1%) [5].
9. Évaluez avec le même protocole de découpage que celui utilisé par la méthode citée la plus proche. Pour les modèles de séquences profondes basés sur NASA, reproduisez les expériences Leave-One-Battery-Out et Temporal Split [2] ou faites varier la taille des données sur 60%, 70%, 80% [1], selon la méthode citée que vous étendez. Ne comparez pas votre nombre à celui d'un autre article sauf si vous réexécutez les deux sur le même découpage.
10. Ajoutez une vérification de calibration. Si vous utilisez un GP, vérifiez que la fonction moyenne encode correctement toute forme connue de modèle de dégradation [13] et vérifiez si une formulation GP à sorties multiples améliore les prévisions en exploitant les corrélations entre cellules [13]. Si vous utilisez un réseau de neurones, rappelez-vous qu'il ne fournit pas de limites de confiance analytiques [14], donc rapportez uniquement des métriques de précision ponctuelle honnêtement plutôt que de prétendre à des intervalles calibrés qu'il ne peut pas produire.
11. Rapportez explicitement les points de défaillance. Notez si les modes de dégradation changent (perte de matériau actif à l'une ou l'autre électrode, ou perte d'inventaire de lithium [12]) de manières que les données d'entraînement ne couvraient pas, et notez si le déploiement correspond aux conditions de fonctionnement (température, protocole) que le jeu de données choisi couvre, puisque des conditions de laboratoire étroites ont été signalées comme un risque de généralisabilité [11].

Le script ci-dessous construit un petit pipeline RUL reproductible sur le schéma SQLite propre au projet. Il lit les barres quotidiennes depuis la table bars (tf='1d'), traite close comme un proxy de la fraction de capacité de la batterie par rapport à sa valeur initiale (un signal de substitution puisque le schéma n'a pas de champs spécifiques aux batteries), et définit la fin de vie comme le point où ce signal normalisé chute à 80% de sa valeur initiale, suivant la définition de fin de vie à 80% de la capacité initiale [11]. Il implémente ensuite trois baselines fidèles aux mécanismes cités à une échelle reproductible et légère pour CPU : (1) un régresseur par processus gaussien avec noyaux RBF et bruit blanc et moyenne nulle par défaut de sklearn, une baseline GP standard qui peut être étendue avec une fonction moyenne de dégradation explicite lorsque la forme fonctionnelle est connue [13] ; (2) un petit régresseur de séquence de style CNN-LSTM (implémenté avec des briques numpy/sklearn simples tenant lieu d'étages de caractéristiques CNN et LSTM) comme baseline pilotée par les données, suivant la structure CNN-puis-LSTM [2][1] ; et (3) une caractéristique simple d'entropie d'échantillon plus une régression linéaire bayésienne ridge, suivant l'idée d'entropie d'échantillon plus modélisation prédictive bayésienne [8]. Le script évalue le RMSE de la RUL prédite (en pas de temps) pour chaque méthode sur une portion mise de côté de la série de chaque symbole, calcule la couverture de l'intervalle de prédiction à 95% du GP, et imprime une table de comparaison. Comme l'exécution utilise les prix de clôture quotidiens AAPL/MSFT/BTC-USD qui ne franchissent jamais le seuil de 80%, find_eol_index retourne la longueur de la série et les valeurs de RMSE (~286 pas) ne portent aucune information sur la précision de la RUL ; la table démontre que le pipeline s'exécute de bout en bout mais ne constitue pas une comparaison de méthodes. La couverture mesurée du GP est d'environ 0.16, bien en dessous de la cible nominale de 0.95, ce qui montre que le noyau et les hyperparamètres de la baseline doivent être réglés avant que le harnais puisse servir de benchmark de calibration. Tout est déterministe et s'exécute sans accès réseau en bien moins de trois minutes sur CPU pour des tailles typiques de table 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))