Détection de valeurs aberrantes

Version imprimable

Bonjour à tous,

Dans le cadre d'une mission que l'on ma confiée, je dois, entre autres, m'occuper de nettoyer des séries de données annuelles de 4 capteurs de température de toutes leurs valeurs aberrantes (bugs des capteurs, températures trop élevées, etc...).
Pour chaque station météo, j'ai donc 4 capteurs placés au même endroit mais à des hauteurs différentes. Mon jeu de données se présente donc de la manière suivante:
Code:

1 2 3 4 5 6 7 8 9 10 capt1 capt2 capt3 capt4 date_time -0.25 -2.43 -3.25 -2.37 01/01/2008 00:00 -0.18 -2.37 -3.18 -2.25 01/01/2008 00:15 -0.25 -2.5 -3.37 -2.56 01/01/2008 00:30 -0.25 -2.37 -3.31 -2.37 01/01/2008 00:45 -0.25 -2.56 -3.37 -2.68 01/01/2008 01:00 -0.25 -2.56 -3.43 -2.56 01/01/2008 01:15 -0.25 -2.56 -3.43 -2.37 01/01/2008 01:30 -0.25 -2.62 -3.56 -2.81 01/01/2008 01:45 -0.25 -2.68 -3.5 -2.75 01/01/2008 02:00
J'ai une mesure de température toutes les 15mn, tous les jours sur une année entière (soit environ 35000 mesures par capteur et par an).

Mon soucis actuel est donc de trouver une fonction robuste qui puisse scanner ces 4 colonnes de données, y détecter les valeurs aberrantes et les remplacer par NA.

J'ai déjà essayé avec l'écart type ("sd"), mais cela ne fonctionne pas assez étant donné l'importance du jeu de données.
J'ai également essayé en lui demandant de remplacer par NA les valeurs supérieures et inférieures à un certain seuil (par exemple +40 et -40°C). Cela fonctionne mais ça ne permet pas de détecter et de supprimer les petits pics aberrants comme dans l'exemple ci-dessous:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 capt1 capt2 capt3 capt4 date_time 2.43 4.93 6.18 6.93 09/01/2008 15:30 2.43 4.81 6.18 6.93 09/01/2008 15:45 6.93 4.68 6.18 6.93 09/01/2008 16:00 2.93 4.93 7.93 6.43 09/01/2008 16:15 2.93 4.43 5.81 6.18 09/01/2008 16:30 6.93 4.43 5.68 15.93 09/01/2008 16:45 6.93 4.31 7.93 15.93 09/01/2008 17:00 7.93 4.43 15.93 15.93 09/01/2008 17:15 7.93 4.43 5.43 15.68 09/01/2008 17:30 7.93 7.93 5.06 7.68 09/01/2008 17:45 7.93 7.93 5.93 15.93 09/01/2008 18:00 7.93 7.93 5.93 15.68 09/01/2008 18:15
On voit pour le capt4 une augmentation brutale de 10°C en 15mn (de 6.18 à 15.93°C) de la température, ce qui est très probablement faux, et que cette erreur persiste ensuite plusieurs fois (sauf pour le 7.68°C qui doit être juste).
J'aimerais donc arriver à pouvoir supprimer ces valeurs fausses (en l'occurence dans cet exemple tous les 15.93°C faux et encore d'autres erreurs du même type) dans ma série de données.
Existe-il une méthode statistique sous R qui puisse détecter ces valeurs et les remplacer par NA?
En cherchant un peu, je suis tombé sur la fonction cov.mcd de la librairie "MASS" mais je ne sais pas ce qu'elle vaut et si elle peut m'aider.
Merci beaucoup d'avance pour vos idées et votre aide!

19/03/2012, 15h36
Anthony Vager

Bonjour jeff6868,

Désolé de te décevoir mais je n'ai pas de solution à ton problème car j'ai approximativement la même problème que toi :calim2: , donc par contre j'attends les aides qui pourraient suivre moi aussi :oops:

Salut anthony,

Ecoute, moi j'ai trouvé une solution à ce problème de valeurs fausses qui se répètent sur un autre forum. Si par exemple 2 valeurs fausses se suivent, il s'agit de comparer la 2e fausse non pas à la première fausse mais avec la dernière valeur "juste" relevée, à partir de la conditions que tu définis. Donc ca peut fonctionner pour une longue série de valeurs fausses (même si celles-ci ne sont pas tout à fait égales mais fausses quand même).
Je te donne l'exemple de mon code si ça peut t'aider dans le tien:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 out2NA <- function(x,maxi,seuil){ st1 = NULL temp <- st1[1] <- x[1] # variable temporaire mémorisant la dernière valeur "correcte" relevée st1 <- ifelse (abs(x)>maxi, NA,x) for (i in 2:length(x)){ if(!is.na(x[i])){ if((((x[i]) - temp) >= seuil)&(abs(x[i])<=temp+15)){ st1[i] <- NA }else { #&(abs(x[i])>=abs(x[i+1])-0.6) temp <- st1[i] <- x[i] } } } return(st1) }
Par contre j'ai un autre soucis, peut être que tu peux m'aider.
Je bosse en fait sur 4 colonnes. Un exemple ci-dessous:
Code:

1 2 3 4 5 dat1 dat2 dat3 dat4 2 4 3 5 5 1 2 8 0 0 0 0 1 3 6 1
Je souhaiterais supprimer et remplacer par NA les valeurs identiques dans les 4 colonnes (dans le bout de code que j'ai mis au début), c'est à dire passer du tableau ci-dessus à celui-ci:
Code:

1 2 3 4 5 dat1 dat2 dat3 dat4 2 4 3 5 5 1 2 8 NA NA NA NA 1 3 6 1
Tu as une idée comment faire? J'ai essayé avec unique() ou duplicated() mais je n'arrive pas pour l'instant

Bonjour,

Voici une idée qui me semble fonctionner :

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
## matrice de données créée pour tester la fonction ##
 
M<-matrix(c(2,4,3,5,5,1,2,8,0,0,0,0,1,3,6,1,1,1,1,2,8,8,8,8),byrow=TRUE,ncol=4)
 
M
     [,1] [,2] [,3] [,4]
[1,]    2    4    3    5
[2,]    5    1    2    8
[3,]    0    0    0    0
[4,]    1    3    6    1
[5,]    1    1    1    2
[6,]    8    8    8    8
 
 
## fonction qui va tester si tous les éléments d'un vecteur sont identiques :
si oui elle va retourner un vecteur de NA, si non elle va retourner le vecteur initial ##
 
testunique<-function(x)
{
	u<-unique(x)
 
	if(length(u)==1)
	{
		res<-rep(NA,length(x))
	}
	else
	{
		res<-x
	}
 
	return(res)
}
 
 
## on va utiliser une fonction de la famille "apply" pour appliquer la fonction précédente 
sur toutes les lignes de notre matrice M ##
 
Z<-t(apply(M,1,testunique))
 
Z
     [,1] [,2] [,3] [,4]
[1,]    2    4    3    5
[2,]    5    1    2    8
[3,]   NA   NA   NA   NA
[4,]    1    3    6    1
[5,]    1    1    1    2
[6,]   NA   NA   NA   NA

Si vous voulez plus d'explications, n'hésitez pas.
Pour obtenir des infos sur les fonctions de type "apply", tapez dans R : ?apply, ?sapply, ...

Cordialement,

A.D.

Bonjour,

Tout d'abord merci pour votre réponse et vos explications détaillées.
J'ai appliqué votre proposition à mon script en l'adaptant, et cela fonctionne parfaitement! Merci beaucoup!

Je profite de votre savoir suprême en langage R pour vous poser une dernière question à propos de mon script, car il me reste un dernier problème à résoudre pour que toutes mes données soient correctement filtrées.

Mes données concernent des mesures de température. J'ai tout d'abord créé une série temporelle afin entre autres de remplacer par NA les jours où il n'y a pas eu de mesures (donc du NA introduit au préalable de la fonction supprimant les valeurs aberrantes).
J'applique ensuite une fonction qui vise à supprimer les valeurs aberrantes qui se répètent (ou non) avec le code ci-dessous:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 out2NA <- function(x,maxi,seuil){ st1 = NULL temp <- st1[1] <- x[1] # variable temporaire mémorisant la dernière valeur "correcte" relevée st1 <- ifelse (abs(x)>maxi, NA,x) for (i in 2:length(x)){ if(!is.na(x[i])){ if((((x[i]) - temp) >= seuil)){ st1[i] <- NA }else { #&(abs(x[i])>=abs(x[i+1])-0.6) temp <- st1[i] <- x[i] } } }
J'aimerais encore pouvoir dire sous R (dans le code ci-dessus) qu'il applique donc ce calcul avec la fonction "temp", mais qu'il arrête le calcul lorsqu'il rencontre du NA qui a été déjà créé (et donc qu'il reparte à partir de la première valeur après le NA). A l'heure actuelle, si la dernière valeur mesurée est fausse avant une période sans mesure (donc avec du NA), il va comparer la première valeur après la fin du NA avec la dernière valeur "juste" rencontrée.
Par exemple, si le 15 janvier à 12:00 il fait 5°C (c'est juste), à 12:15 il fait 20°C (c'est faux) et à partir de 12:30 jusqu'au 10 mars par exemple il n'y a pas eu de mesures (donc du NA), il va comparer la première valeur du 10 mars avec la dernière "juste" du 15 Janvier, du coup l'écart est naturellement important (sans être faux) et il va mettre du NA à toutes les valeurs "justes" de mars (j'ai observé le cas en testant), car pour lui il y a un bond trop important entre les 2 données (et donc avec les valeurs qui suivent aussi).
J'espère avoir été clair. Y'a-t-il une façon de lui dire ça (qu'il arrête le calcul quand il rencontre du NA, ou bien qu'il tienne en compte le NA dans le calcul pour arrêter la suppression)?
En vous remerciant d'avance.
Bonne fin de journée
Cordialement

21/03/2012, 10h29
A. D.

Bonjour,

Je n'ai pas trop le temps de regarder votre code en détails pour le moment, mais comme vous semblez faire une boucle, pourquoi ne pas stocker à chaque itération (dans une variable DER par exemple) la dernière valeur uniquement si celle-ci est différente de NA (sinon la variable DER conserve sa valeur), et effectuer vos comparaisons par rapport à cette dernière valeur stockée dans DER?

Je ne sais pas si c'est très clair, peut-être que cela peut vous donner une piste...

Cordialement,

A.D.
21/03/2012, 11h53
jeff6868
Bonjour,

Si je crois plus ou moins comprendre cette histoire de variable stockant la dernière valeur qui est différente de NA, je pense qu'il s'agit plus ou moins de ce que je fais déjà à travers la variable "temp" si-dessous:

Code:

temp <- st1[1] <- x[1]

Elle permet en effet d'effectuer le calcul dans la boucle, si par exemple une valeur aberrante est détectée et que la suivante l'est aussi, la variable "temp" mémorise la dernière valeur "juste" relevée (donc ici celle qui précède la première valeur fausse), et compare à chaque fois cette dernière valeur "juste" avec la valeur suivante, tant que celle-ci est détectée comme aberrante. Lorsqu'une valeur "juste" est à nouveau détectée, il mémorise cette nouvelle valeur et effectue ses comparaisons avec les valeurs suivantes à partir de cette nouvelle valeur "juste".

Seulement le soucis, c'est que si la dernière valeur "juste" est suivie par une longue période de données manquantes (2 mois par exemple), la boucle va comparer la première valeur de température après cette période avec la dernière avant la période, comme dans l'exemple inventé ci-dessous:
Code:

1 2 3 4 5 6 7 8 31/01/2008 12:00 2.4 01/02/2008 12:00 1.2 02/02/2008 12:00 NA 03/02/2008 12:00 NA 04/02/2008 12:00 NA [...] NA 25/04/2008 12:00 24.3 26/04/2008 12:00 25.2
Avec ma boucle actuelle, il va garder en mémoire le 1.2°C du 1er février et le comparer avec le 24.3°C du 25 avril, et va donc y voir un écart important et donc remplacer par NA la donnée du 25 avril mais aussi celle du 26, car étant proche de celle du 25 (donc fausse aussi pour lui).
Comme cela est évidemment faux, j'aimerais en fait lui dire dans cet exemple qu'il arrête son calcul au 1.2°C (car il y a du NA déjà présent après) et qu'il reparte à partir du 24.3°C d'avril et donc d'effectuer les comparaisons avec les valeurs qui suivent à partir de ce 24.3°C et non du 1.2°C.
Voilà, j'espère avoir été le plus clair possible.
22/03/2012, 11h51
A. D.
Bonjour,

Effectivement, votre code fait déjà ce que je vous proposais, mais je n'avais pas bien compris ce que vous souhaitez faire...

Si j'ai bien compris cette fois, pourquoi ne pas ajouter dans la boucle un test sur x[i-1] du genre à l'étape i :
- Si x[i-1] différent de NA, on fait la boucle classique telle que vous l'avez écrite actuellement
- Si x[i-1] et x[i] valent tous les deux NA, on ne fait rien et on passe à l'itération suivante
- Si x[i-1] vaut NA et x[i] une valeur, on remplit "temp" avec la valeur de x[i], et on passe à l'itération suivante (qui, si x[i+1] est différent de NA, va entrer dans le point 1 de la présente liste et suivre le processus itératif "classique" tel que vous l'avez écrit)
Ai-je bien compris ce que vous cherchez à faire? Si oui et que vous avez des soucis à programmer cela, n'hésitez pas à venir les détailler.
En espérant vous avoir aidé :)

Cordialement,

A.D.

Bonjour,

Alors en fait pour ce problème, j'ai pensé jouer sur le calcul en tenant compte de l'écart entre les dates des 2 mesures à comparer.
Si par exemple dans mes données j'ai une période de données manquantes (donc NA), je lui dis que si l'écart-temps entre la dernière valeur avant les données manquantes et la première valeur après les données manquantes est supérieur à 1h par exemple, il ne compare pas ces 2 valeurs mais passe directement à la première valeur après le NA. Dans l'exemple ci-dessous, on a pas de données du 8 avril 10h au 8 avril 11h.
Code:

1 2 3 4 5 6 7 8 9 08/04/2008 09:30 4.75 08/04/2008 09:45 4.81 08/04/2008 10:00 NA 08/04/2008 10:15 NA 08/04/2008 10:30 NA 08/04/2008 10:45 NA 08/04/2008 11:00 NA 08/04/2008 11:15 10.10
Lorsque je vous avais posé la question avant-hier, il me comparait (dans le cas de cet exemple), la valeur du 8 avril 11h15 avec celle du 8 avril 9h45, ce que je ne veux pas qu'il fasse. Je voulais au contraire que si l'écart entre 2 valeurs (entrecoupé de NA) est supérieur à 30mn (donc 2 lignes de NA), alors qu'il ne compare pas la valeur du 8 avril: 11h15 et 9h45 mais qu'il compare celle de 11h15 avec celle de 11h30 (donc qu'il arrête à la dernière valeur numérique avant le NA (si il y a plus de 2 lignes de NA) et qu'il recommence les comparaisons à partir de la première valeur numérique après ce NA.

J'ai donc introduit cette notion d'écart-temps dans mon code:
Code:

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 # Fonction supprimant les valeurs aberrantes # out2NA <- function(x,maxi,seuil,ecart_temps){ st1 = NULL # Variable temporaire mémorisant la dernière valeur "correcte" relevée # temp <- st1[1] <- x[1] # Conserver l'indice de la valeur tampon # ind_temp <- 1 # Conserver les temps de chaque élément de la série temporelle # tps <- time(x) # Suppression des valeurs absolues >= au seuil "maxi" # st1 <- ifelse (abs(x)>=maxi, NA,x) # Suppression des valeurs absolues dont l'écart avec la précédente est >= au seuil défini # et suppression des valeurs suivantes si la valeur aberrante se répète # for (i in 2:length(x)){ if(!is.na(x[i])){ if((tps[i]-tps[ind_temp] < ecart_temps) & (abs(x[i] - temp) >= seuil)){ st1[i] <- NA } else { temp <- st1[i] <- x[i] ind_temp <- i } } } return(st1) }
Mais il reste un problème malgré tout (quand on pense résoudre un problème, on en recréé un autre... c'est les joies de la programmation).

Si par exemple je définis l'écart temps = 5 (donc 5 lignes de NA), il tient bien en compte les périodes où j'ai déjà du NA avec donc au moins 5 valeurs.
Mais lorsque ma boucle détecte pour le calcul une série de valeurs numériques fausses dans mes données, si le nombre de ces valeurs fausses à la suite est plus grand que l'écart temps, il va arrêter de les remplacer par NA au seuil de l'écart temps.
Donc si par exemple j'ai définis l'écart temps à 5, et que à un moment j'ai 10 valeurs numériques fausses qui se suivent, il ne va remplacer par NA que les 5 premières et pas les 5 suivantes.
Or j'ai besoin de définir mon seuil "ecart_temps" autour de 2 ou 3 car il arrive que j'ai des données manquantes seulement pendant 30mn ou 1h.
Voilà, j'espère que vous avez compris et que vous pourrez encore m'aider sur ce point, car je ne n'ai pas d'idées sur comment le résoudre et le programmer. Merci encore de m'accorder un peu de votre temps. (Et désolé si j'écris beaucoup, mais j'essaie d'être le plus clair et détaillé possible comme mon problème est assez complexe et que j'ai des données à traiter particulièrement biscornues).

27/04/2014, 18h01
miss_ana

Bonjour ,
Par contre moi, je cherche ce genre de jeu de données. Où est-ce que je peux les trouver ? jeff6868, est-ce que vous pouvez m'aider ?