Discussion :

[Caylith]

Bonjour à tous,


Je ne sais pas si je suis dans le bon forum (sinon merci de m'indiquer la voie !), mais je souhaite trouver un moyen de supprimer des valeurs aberrantes, pas dans un ensemble de données, mais dans un flux de données.

Ce flux est généré par un régulateur PID, sous forme de signal dont je vous fais grâce des détails, mais qui fournit une valeur en % chaque seconde. Ces valeurs sont récupérées par un automate programmable, qui les exploite et peut en faire des calculs simples.

Le problème à résoudre : le régulateur envoie des données entachées d'un certain "bruit", et fournit parfois des valeurs carrément aberrantes. Exemple ci-dessous :

0,204253
0,204353
0,204057
0,203862
0,204146
0,203241
0,273856
0,269893
0,198947
0,204200
0,204540
0,205390
0,204444
0,204188
0,279051
0,204530
0,203454
0,208714
0,209387
0,210538
0,209179
0,208428


Je souhaite donc trouver un moyen (un algo en quelque sorte) de repérer ces valeurs et de les supprimer. J'ai fait un premier essai en "lissant" les données par une moyenne des 5 dernières valeurs glissantes. Cela permet de réduire les aberrations mais ce n'est pas efficace quand il y en a 4 ou 5 qui se suivent.

Autre élément important dans ce problème : la moyenne globale est susceptible de changer. Dans l'exemple ci-dessus, les valeurs "normales" tournent autour de 0,205, mais ce chiffre peut augmenter ou baisser dans la durée. Les valeurs aberrantes d'une période peuvent très bien être normales à un autre moment.


Auriez-vous des idées sur un moyen de résoudre ce défi ?


Merci d'avance pour votre aide, et toutes les idées, mêmes embryonnaires, sont les bienvenues !

[phryte]

Bonjour,

Tu peux essayer la différentiation (diff avec Matlab) en mettant un seuil.

[François DORIN]

J'ai fait un premier essai en "lissant" les données par une moyenne des 5 dernières valeurs glissantes. Cela permet de réduire les aberrations mais ce n'est pas efficace quand il y en a 4 ou 5 qui se suivent.

Et en remplaçant les 5 dernières valeurs par les 5 dernières valeurs valides (donc filtrées) ?

[tbc92]

Au moment où tu dois arbitrer pour la valeur de rang I, tu connais déjà les valeurs suivantes ?

Par exemple, pour valider la valeur 0.208714, tu sais déjà que les suivantes seront 0.209387 puis 0.210538 ?
Si tu ne le sais pas, il y a de forts risques de dire que ce 0.208714 est faux.

Si tu connais toutes les données au moment de lancer le process, je procéderais par entonnoir.
Pur valider la valeur de rang i, tu calcules la moyenne E et l'écart-type S des 5 valeurs précédentes et des 5 valeurs suivantes (en excluant la valeur de rang i, et en excluant les valeurs marquées comme fausses), puis tu testes si la valeur de rang i est entre E - k*S et E + k*S avec k = 3 par exemple.
Ainsi, tu vas éliminer les plus grosses aberrations.
Tu testes toutes tes valeurs avec cette méthode.
Puis tu recommences en prenant k = 2.5, puis k=2 puis k = 1.5

Au lieu de prendre la moyenne et l'écart-type, tu peux aussi utiliser la médiane, et l'EIQ (Ecart-inter-quartile). L'avantage de ces 2 indicateurs, c'est qu'ils sont beaucoup moins sensibles aux valeurs aberrantes.

Par exemple, au moment de valider le 0.273856, tu ne sais pas encore que le 0.269893 est faux. Ce 0.269893 va peser lourd sur la moyenne et sur l'Ecart-type. Alors qu'il va peser quasiment rien sur la médiane ou l'EIQ.

Avec la médiane et l'EIQ, tu peux peut-être faire ton traitement en une seule passe (pas besoin de retraiter avec des filtres de plus en plus serrés).

[wiwaxia]

Bonjour,

Il y a peut-être plus simple, les valeurs inadmissibles se situant au-dessus des autres:
# la plus grande des valeurs acceptées (0,210538) ne dépasse que de 1.9% la moyenne des 4 précédentes (0.206521), tandis que
# pour les résultat aberrants, le dépassement dépasse 30 % !
L'installation d'un filtre d'élimination ne doit donc pas poser de difficulté, en fixant un seuil à 5 ou 10 % .

L'allongement de la liste L2, qui ne contient que les valeurs "normales", se fera par comparaison du nouveau terme examiné (L1[k]), provenant de la liste initiale, avec les 4 derniers de la nouvelle liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
s:= L2[i - 4] + L2[i - 3]; Inc(s, (L2[i - 2] + L2[i - 1])); m:= s / 4;
e:= |L1[k] - M|; 
IF (e<(0.08 * M) THEN  L2[i]:=  L1[k];

[phryte]

Bonjour,
Une idée :
1-Calcul de la moyenne : moy
2-Calcul de l'écart-type : ect
3-Test : si M > moy+2*ect alors on retire la valeur de M et retour à 1

Exemple avec Matlab :

Code matlab :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
M=[0.204253
    0.204353
    0.204057
    0.203862
    0.204146
    0.203241
    0.273856
    0.269893
    0.198947
    0.204200
    0.204540
    0.205390
    0.204444
    0.204188
    0.279051
    0.204530
    0.203454
    0.208714
    0.209387
    0.210538
    0.209179
    0.208428];
L=length(M)
n=0;
while n<L-1
    n=n+1;
    ect=std(M);
    moy=mean(M);
    if M(n)>moy+2*ect
        M=[M(1:n-1);M(n+1:end)];
        L=length(M);
        n=0;
    end
end
M

[Nebulix]

La meilleure solution, de très loin, est de comprendre ce qui crée ces valeurs aberrantes et d'y remédier. Car quel que soit le filtre que tu utilises, il y aura toujours des valeurs "limites" dont tu ne pourras déterminer vraiment la validité.

[Caylith]

Bonjour, et merci pour vos premières réponses. Je vais répondre à toutes vos interrogations d'un coup.

Il s'agit d'un flux de données continu, donc non, je ne connais pas les valeurs suivantes au moment où je reçois la valeur courante. Il faut que l'algo décide de garder ou rejeter la valeur courante sur la foi des valeurs passées uniquement (et donc il n'y a, par définition, qu'une "passe").

Cependant, il est envisageable de créer une file d'attente sur quelques valeurs, qui permet de retarder un peu la décision, et de la prendre sur la base des valeurs passées et de quelques valeurs "à venir". Dans ce cas il faut toutefois se limiter à "quelques" valeurs (je dirais 3 à 5 maximum). En effet, ce flux issu du régulateur PID est là pour piloter un process, donc un retard trop grand entraînerait une perturbation dans la chaîne de régulation. Comme il s'agit d'un process thermique, on peut se permettre une dizaine de secondes de retard.


Pour répondre à Phryte, l'utilisation de Mathlab est exclue, c'est l'API qui peut faire un calcul, en temps réel, avec des fonctions moins élaborées que celles d'Excel par exemple. Je peux calculer une moyenne et un écart-type, par contre je ne connais pas les fonctions "médiane" et "EIQ". TBC92, peux-tu m'indiquer comment cela se calcule ? Si cette méthode est moins sensible aux valeurs aberrantes, cela m'intéresse, car il arrive qu'un assez grand nombre de valeurs aberrantes se succèdent !

Enfin l'observation de Wiwaxia est intéressante, et j'ai remarqué hier que les valeurs aberrantes obéissaient à quelques lois, un peu vagues, mais assez fiables... Je vais essayer de mettre un graphique en PJ...

[Je n'y parviens pas mais j'essayerai ce soir sur un autre PC]

(à suivre)

[tbc92]

La médiane :
Si tu as n données, tu les tries de la plus petite à la plus grande. La médiane est la donnée de rang n/2. Si n est impair, c'est facile, si n est pair, exemple n=20, tu peux prendre au choix la donnée de rang 10, 11 , ou bien la moyenne des 2.

Pour l'écart inter Quartile (EIQ), on va commencer par définir les 2 Quartiles :
Quartile : Comme pour la médiane, on trie les données de la plus petite à la plus grande, et on prend la donnée de rang n* 0.25 . Là encore, selon que n est multiple de 4 ou pas, on va avoir à gérer des arrondis... mais on peut faire des impasses. Le quartile 1 est donc la valeur qui correspond à : 25% des données sont en-dessous de cette valeur.
Et le 3ème Quartile Q3, c'est le symétrique ; on prend 25%, mais en partant de la valeur la plus élevée.
Ecart Inter Quartile = Q3-Q1.

Application :
Tu as reçu les 15 premières lignes de ton flux ; La valeur médiane est 0.204253. Q1 vaut 0.204057 et Q3 vaut 0.205390. Idéalement, il faut calculer Q1 et Q3 sur des données le plus propres possible, mais même si on n'a fait aucun nettoyage, Q1 et Q3 correspondent en général à des valeurs 'propres'. Ici, si on a déjà déterminé que les valeurs 0,273856 et 0,269893 sont foireuses, c'est mieux ; ça permet de les exclure purement et simplement de l'historique.


EIQ = Q3 - Q1 = 0.205390-0.204057 = 0.001333.
Après, connaissant la médiane M et EIQ, on accepte les données qui sont dans un intervalle [ M-k*EIQ , M+k*EIQ ]. A toi de choisir une valeur pour k, pour trouver le meilleur compromis.

Tu peux aussi appliquer une formule comme [ M-k*EIQ -0.005, M+k*EIQ +0.005] . Sinon, sur ton exemple, après toute une série de valeurs qui sont entre 0.203 et 0.204, tous les algorithmes 'statistiques' que tu vas bâtir vont considérer que le 0.208714 est une anomalie.

[Caylith]

J'ai réussi à mettre la courbe dans le post précédent.


Ce qu'on peut y voir, comme je le disais, c'est que :

0) Le régulateur PID fournit des longues plages de valeurs identiques (je m'étais attendu à avoir une courbe plutôt que des escaliers...)
1) Le bruit est très faible,
2) Les valeurs aberrantes se détachent franchement par leur amplitude,
3) Par chance, l'amplitude des valeurs aberrantes est franchement supérieure à l'amplitude des "steps" normaux (qu'il ne faut pas évacuer, bien sûr),
4) À une exception près, tous les steps sont précédés de valeurs aberrantes,
5) Ces dernières sont asymétriques : avant un step positif, les valeurs aberrantes sont plutôt positives, et inversement,
6) Côté droit du graphique, on voit que le système entre en oscillation, sans toutefois diverger.


Alors compte tenu des points 1 à 3, j'ai fait une première tentative (par simulation avec Excel) de lissage en évacuant les valeurs éloignées de la médiane, celle-ci étant calculée sur 11 valeurs. Et ces valeurs aberrantes sont remplacées par la médiane, justement. En choisissant le seuil adéquat, le résultat est déjà pas mal (en bleu les valeurs d'origine, en rouge le signal corrigé) :



À noter que cette correction a un effet positif sur la période d'oscillations. Il reste deux problèmes à régler : en cas de fort changement de signal, l'algo rejette toutes les valeurs suivantes, et en cas de valeurs aberrantes répétées, il évacue les premières mais au bout d'une dizaine de valeurs, il finit par les considérer correctes.


Concernant les oscillations qu'on voit à droite du graphique, je pense qu'elles sont liées à l'interaction entre le régulateur et l'API, dans certaines conditions où le temps de réponse du procédé arrive juste au mauvais moment par rapport au régulateur. Les réglages des paramètres P,I,D doivent être affinés, ce qui résoudra peut-être le problème.

Cela dit, comme le dit Nebulix, le mieux serait d'avoir un régulateur qui envoie des valeurs fiables, mais on fait avec ce qu'on a... J'ai noté à ce sujet qu'en modifiant la fréquence d'envoi des données (par exemple en envoyant 1 valeur toutes les 4s au lieu de 1s), le bruit se réduit, mais cela ne change en rien la fréquence et l'amplitude des valeurs aberrantes.



Ceci étant dit, je vais bien sûr m'employer à améliorer ce premier essai, mais j'aimerais aussi travailler sur la seconde piste, qui consisterait à travailler non pas sur les 11 dernières valeurs pour décider si la 12ème est correcte, mais à faire entrer chaque nouvelle valeur dans un file d'attente (style FIFO), et de lancer chaque fois un algorithme qui détecte, dans cette file, les valeurs aberrantes et les supprime. Ainsi, quand une valeur a parcouru toute la file, on est sûr qu'elle est valide.

Là encore si vous avez des idées elle seront bienvenues.

Merci pour votre aide.

[phryte]

Bonjour,

As-tu essayé un FAE (Filtre Avant Echantillonnage) ?

[wiwaxia]

Bonjour,

J'ai regardé d'un peu plus près la liste initiale des valeurs numériques, et l'examen confirme les observations sommaires précédentes: les valeurs à rejeter s'écartent nettement de celles du palier qui les précède ou dans lequel elles s'insèrent, ce qui facilite leur repérage et leur élimination.
Démonstration graphique (s'il en était besoin) par l'aspect du nuage des 21 points de coordonnées (x_k, x_k+1) - tracé un peu négligé, faute de temps:

Il faut que l'algo décide de garder ou rejeter la valeur courante sur la foi des valeurs passées uniquement (et donc il n'y a, par définition, qu'une "passe").
Cependant, il est envisageable de créer une file d'attente sur quelques valeurs, qui permet de retarder un peu la décision, et de la prendre sur la base des valeurs passées et de quelques valeurs "à venir". Dans ce cas il faut toutefois se limiter à "quelques" valeurs (je dirais 3 à 5 maximum).

Justement, on peut rapidement caractériser le quadruplet des 4 dernières valeurs obtenues par sa moyenne (m) et sa dispersion relative (d = e/m) - où (e) correspond à l'écart quadratique moyen. Les 19 couples successifs (m, d) prennent ainsi les valeurs suivantes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Xk*E<sup>6</sup>     d (%) 
204131    0.09
204105    0.09
203827    0.17
221276   13.72
237784   14.35
236484   14.99
236724   14.88
219395   13.33
203269    1.25
204644    0.22
204641    0.22
223268   14.43
223053   14.49
222806   14.58 
223937   14.24
206521    1.24
208023    1.31
209455    0.32 
209383    0.36

La présence d'un point aberrant saute aux yeux, la dispersion relative des valeurs devenant en moyenne plus de 20 fois plus grande !

Une ou deux valeurs anormales pourront être remplacées par des calculs d'extrapolation, à partir de la droite moyenne ou plus simplement par une relation approchée: X₅ = (1/8)*(7*(X₃ + X₄) - 3*(X₁ + X₂)) .

Et pourquoi pas X₅ = m , puisque la suite des valeurs enregistrées comporte (d'après les derniers documents fournis, tout à fait surprenants) une succession de paliers horizontaux entrecoupés de sauts erratiques ?

[wiwaxia]

... j'aimerais aussi travailler sur la seconde piste, qui consisterait ... à faire entrer chaque nouvelle valeur dans un file d'attente (style FIFO), et [à] lancer chaque fois un algorithme qui détecte, dans cette file, les valeurs aberrantes et les supprime ...

Problème: comment reconnaître les valeurs aberrantes dans une suite comportant deux paliers, voire plus ? Les exemples abondent sur le graphique qui est donné ... Il faudra bien à un moment ou à un autre faire apparaître des groupes de valeurs consécutives, relativement proches, et dont la dispersion ne dépasse pas le seuil du bruit de fond (d < 1.5 % env.).



D'ailleurs, qu'est-ce qu'un palier ? Combien doit-il comporter de points, au minimum ? (1)
Réponse: un palier commence dès qu'on trouve (L_mp) termes consécutifs vérifiant (d < S_bruit); la longueur minimale du palier est arbitrairement choisie (L_mp = 4, 6 ou 8 ?).
Critère de fin de palier: on peut admettre qu'une ou deux valeurs anormales consécutives (|x - m|/m > f * S_bruit , avec f ~ 1.5 à 4, à choisir en fonction des discontinuités observées) ne signent pas la fin du palier, pourvu qu'on retrouve au-delà une valeur suffisamment proche de (m); cette moyenne (m) se substituera alors aux anomalies trouvées.

(1) Ce genre de question n'est pas nouveau: des Grecs se demandaient, il y a vingt-quatre siècles, combien de grains il faut pour faire un tas. Mais là, je m'éloigne du sujet.

[tbc92]

Cette notion de palier est effectivement essentielle.

Vers le milieu du graphique, (environ 3h00) on voit une valeur qui est décalée de quelques pixels par rapport aux valeurs précédentes. Cette valeur est elle correcte, ou non ?
Si on fait l'analyse en temps réel, le décalage n'est pas énorme, c'est peut-être le début d'un nouveau palier.
Et si on a un peu de 'recul', on voit que cette valeur est totalement isolée, les valeurs suivantes sont alignées avec le palier précédent. La valeur décalée est isolée, et donc fausse.

D'où l'utilité d'avoir reçu les 3 ou 4 mesures suivantes, pour diagnostiquer la mesure X.

[Caylith]

Bonjour,


Je n'ai lu qu'en travers les posts précédents, je m'y remettrai à tête reposée, mais juste une petite info : le procédé étant de nature thermique, il a une inertie importante en comparaison de la chaîne de régulation : temps de réponse du procédé = environ 1 à 2 minutes, temps de réponse du régulateur = 1s.

(c'est pour cela que je pense pouvoir me permettre un "retard à la décision" de 10s, mettons 20s maximum, sans que cela ait trop d'influence sur la chaîne de régulation)

Du coup, j'ai un grand nombre de valeurs, et il est exclu d'avoir plus de deux paliers dans une suite de 20 valeurs. Les enregistrements que je vous ai montrés représentent une plage horaire de plus de 10 heures. Donc sur 20 valeurs, on peut envisager d'avoir tout au plus :
- un signal stable bruité,
- quelques valeurs aberrantes,
- un nouveau signal stable bruité, début d'un nouveau palier.


Dès que je peux, j'envoie un graphique d'une montée en température...

PS : c'est quoi un FAE ?

[tbc92]

Tu dis que tu peux attendre 10s ou même 20s. Ok.
Mais dans cet intervalle de 10s, on va recevoir d'autres mesures ? et combien ? Ce point n'est pas clair.

[Caylith]

Oui, il arrive une nouvelle valeur chaque seconde. Donc 10 valeurs en 10s, et comme un retard de 10s me semble acceptable, cela permet éventuellement d'avoir 10 valeurs "futures".

Par exemple, imaginons que j'aie la séquence suivante :

0,222093
0,221572
0,221588
0,221551
0,221657
0,222121
0,221680
0,222250
0,222225
0,221718
0,217012

J'ai donc 10 valeurs dans le bruit autour de 0.221. Le 0,217 est-il une valeur aberrante ou le début d'un nouveau palier ? Difficile à dire, parce que les pics habituels qui précèdent un palier sont plus grands (quoique plus grands dans le sens du futur palier, mais moindre dans le sens inverse).

Donc si je connais les 10 valeurs suivantes, la question devient plus décidable :

0,222093
0,221572
0,221588
0,221551
0,221657
0,222121
0,221680
0,222250
0,222225
0,221718
0,217012
0,222255
0,221699
0,222267
0,222244
0,221721
0,222387
0,222249
0,221705
0,222245
0,221692

Ci dessus, c'est une valeur aberrante (pour info, c'est le petit creux qu'on voit sur la courbe à 3h du matin).

0,222093
0,221572
0,221588
0,221551
0,221657
0,222121
0,221680
0,222250
0,222225
0,221718
0,217012
0,217013
0,217027
0,217016
0,217042
0,217024
0,217025
0,216880
0,217050
0,217035
0,217038

Mais là, c'est un nouveau palier qui commence.

Pour l'algo, cela revient à mettre 21 valeurs dans la file d'attente, et scruter la 10ème.
- Si elle est dans le bruit des 10 précédentes => on la garde,
- Si elle n'est pas dans le bruit, on regarde si elle est dans le bruit des 10 suivantes => si oui on garde, si non on jette.

Ensuite une nouvelle valeur arrive dans la file, tout se décale d'un cran :

0,221572
0,221588
0,221551
0,221657
0,222121
0,221680
0,222250
0,222225
0,221718
0,217012
0,217013
0,217027
0,217016
0,217042
0,217024
0,217025
0,216880
0,217050
0,217035
0,217038
0,217032

Si je calcule la référence des 10 valeurs précédentes avec la médiane, celle-ci ne change pas ou presque, donc le résultat est le même qu'au round précédent => on garde la valeur scrutée. Si la référence est calculée avec la moyenne, celle-ci va se rapprocher progressivement du nouveau palier. Dans les deux cas, au bout d'un moment la valeur scrutée sera dans le bruit, ce qui ramène au cas initial où tout est stable.



Cette méthode permettrait d'évacuer les valeurs aberrantes, même si elles ne sont pas très éloignées du bruit, en ne coûtant que 10s de retard dans la chaîne de contrôle-commande (puisque la valeur scrutée est décidée juste ou fausse, puis injectée immédiatement dans le système de commande). C'est plus efficace que ce que j'imaginais, avec une valeur qui parcourt toute la file d'attente avant d'être vraiment validée.

Mais si cette méthode semble efficace pour des pics isolés, il faut qu'elle le soit aussi avec des pics / creux répétés. Je vais essayer de la simuler avec Excel, on verra ce que ça donne avec un vrai jeu de données.

Pour répondre à la notion de palier, voici deux graphiques, qui montrent une rapide montée en puissance (et on voit que ma simulation d'algo de lissage décroche au bout d'un moment). Vue large et zoom sur la montée.





Le palier le plus court ne dure que 6s. On comprend qu'il faudra adjoindre à l'algo un système de rattrapage qui, en cas de décrochement, redonne confiance dans les valeurs jugées aberrantes... (mais on verra cela plus tard !)

[tbc92]

Ces graphiques sont très beaux, mais concrètement, ils ne font pas avancer la décision.
Par exemple, les valeurs qui arrivent vers 20:00:35 ou 20:00:38, tu veux les garder, ou pas...

Et idem la valeur de 0.30 vers 20:01:52, il faut la garder, ou pas ?

Plus généralement, tu as souvent la configuration suivante :
- un palier à une valeur de x,
- un palier à une valeur de y
- et entre les 2, 1 ou 2 valeurs proches de x+ 1.3*(y-x). Que faire de ces valeurs un peu décalées ?

[Vincent PETIT]

Bonjour a tout le groupe,
Je ne vais pas faire avancer le problème et j'en suis désolé mais c'était juste pour dire que les valeurs qualifiées de aberrantes ne le sont pas en réalité. Ces valeurs sont très gênantes mais elles sont inhérentes a tout régulateur PID.
Ce qu'on voit est très probablement le dépassement durant le temps d'établissement du régime stationnaire de n'importe quel régulateur PID.

Source Wikipédia : https://fr.wikipedia.org/wiki/R%C3%A9gulateur_PID

Suivant le réglage des coefficients P, I et D on joue sur le temps de montée (rapidité du système), la hauteur du dépassement qui est une oscillation qui dure pendant le temps de l'établissement du régime stationnaire (stabilité du système) et l'erreur (précision par rapport a la consigne désirée.) Tu n'as pas accès a ces réglages ?

A tout hasard, tu peux donner le fichier Excel ou une partie ?

[Caylith]

Bonjour Vincent, et merci pour ta contribution.


Les oscillations auxquelles tu fais référence correspondent bien à l'évolution globale de mon signal qu'on peut observer sur la totalité de la plage ci-dessous (montée et dépassement les points (2) et (3), et retour à la consigne en (9) et +). Actuellement j'affine mes paramètres P,I,D petit à petit pour limiter les trop grandes évolutions. Ce qui me gêne, ce n'est pas cette évolution mais c'est les pics et creux inutiles au sein du signal, par exemple, ceux qu'on voit très bien vers les points (5) et (6). Ceux-ci sont gênants car ils perturbent parfois le système (variations de puissance intempestives alors que la charge est stable).


Mais comme dit Tbc92, c'est vrai que mon "cahier des charges" n'est pas très clair. Ce que je veux, c'est nettoyer le signal pour enlever les pics et creux inutiles, mais conserver les variations "légitimes".

La simulation suivante (valeurs d'origine en bleu, et simulation de lissage en rouge) donne de bons exemples :



- Zone 1, j'y reviendrai à la fin
- Zone 2 : le signal corrigé suit le signal brut en limitant les pics, c'est bien (ce serait même mieux si on passait directement à la valeur du palier sans passer par le pic.
- Zone 3 : l'algo a décroché => pas bien !
- Zone 4-5 : le signal corrigé suit parfaitement le signal brut et évacue les pics => très bien...
- ...sauf en début de zone 4 et en zone 6 où il reste des pics résiduels => pas bien !
- Zone 7 : parfait (pics bas évacués, il reste les petits pics hauts mais ils sont, à vue de nez, acceptables pour ne pas être trop perturbateurs)
- Zone 8 : pas mal d'oscillations sont évacuées (bien !), mais d'autres sont restées (pas bien !)
- Zones 8 et 9 : on voit que le signal est passé de la zone 7 à la zone 9 en passant par la 8 où le signal était plus bas. Cette baisse temporaire (environ 2 minutes) n'avait pas d'intérêt par rapport au process. Il s'agit probablement d'un problème de réglage des paramètres P, I, D, est ce n'est en principe pas le rôle de l'algorithme de le corriger. Néanmoins je garde dans un coin de ma tête l'idée de lisser cela aussi si c'est possible.
- Zone 1 : pareil, le signal est passé, en valeur, de 0,11 à 19h58, à 0,13 à 20h01, en passant par un phase à 0,16, qui n'avait pas d'intérêt. Si déjà je peux supprimer les pics, c'est bien, si je peux enlever ces périodes "inutiles" (passer directement de 0,11 à 0,13 sans monter à 0,16 pendant 2 min), c'est mieux, mais cela n'est évidemment pas la priorité.