Comparer des lignes entre elles

Version imprimable

Bonjour,

J'ai un grand jeu de donnée provenant d'arbres.
Dans la première colonne, il y a ce que l'on appelle des numéro de clones. Chaque numéro de clone est présent en plusieurs copie (de 1 à 5). Il s'agit d'arbres qui sont normalement identiques
Dans les colonnes suivante, il y a des allèles (80 allèles en tout).

Le but est de vérifier si les arbres portant le même numéro de clone ont bien tout leurs allèles identiques.
Si au moins deux allèles diffèrent, alors les arbres sont considérés comme différents, ce ne sont pas de vrais clones. Il y pas mal de données manquantes pour certains allèles, qui ne doivent pas être considérées comme des différences.

Clones Individu Allele1 Allele2 Allele3 etc

clone1 1 A T CG etc

clone1 2 A T CG etc

clone1 3 A T CG etc

clone1 4 A T AT etc

clone1 5 A T CG etc

clone2 etc

clone2 etc

-> l'individu 5 parmi les 5 "clone1" est différent. Ce n'est pas un clone.

Voici comment j'envisageais la chose, en terme de logique. Peut-être avez vous mieux a proposer?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # sélection de tout les arbres issu d'un clone. # -> return nombre de données manquantes pour chaque arbre. # # création d'un vecteur contenant les allèles supposés corrects # -> On regarde tout les clones, et on estime que si un allèle apparait au moins trois fois pour cette colonne, alors il est correct. Autrement, il est faux. # # comparaison de chaque échantillons avec le vecteur supposé correct # -> return nombre de différences (ne pas comparer si allèle manquant) # si nb de difference>2 = individus différents # si nb de difference<2 = individus identiques. #output : #un data frame contenant tout les arbres considéré comme différent du vecteur supposé correct. Return nombre de differences. #
Quelles fonctions dois-je utiliser pour mener a bien cette tache selon vous?

Merci de votre aide.

Clones	Individu	Allele1	Allele2	Allele3	etc
clone1	1	A	T	CG	etc
clone1	2	A	T	CG	etc
clone1	3	A	T	CG	etc
clone1	4	A	T	AT	etc
clone1	5	A	T	CG	etc
clone2	etc
clone2	etc

bonjour, j'ai fait un petit script à tester
la fonction principale est verifier_clone

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
48
49
50
51
52
53
54
55
56
57
58
 
## df fichier des clones :  les données manquantes sur les allèles ==> NA
 
df<-df %>% select_all(str_to_lower) ## on mets en minuscule nom des colonnes
#  "clones"   "individu" "allele1"  "allele2"  "allele3"  ...
 
# ajout colonne serie qui aggrege  les allèles
df <-df %>% bind_cols(  unite(data=df %>% select(-1,-2),col = "serie",names(df)[c(-1,-2)],sep="_")) %>% 
  mutate(serie = str_replace_all(serie,"_NA_","_*_")) ## om mets une étoile * si donnée sur allèle est manquante
 
remplacer_manquant <- function(list_pattern_clone,list_pattern_diff)  {
  ## fonction qui remplace les données manquantes par la valeur de la donnée des clones
  res <- map(1:nrow(list_pattern_diff),
             ~map_chr(1:ncol(list_pattern_diff),~ifelse(list_pattern_diff[.y,.x]=="*",list_pattern_clone[.x],list_pattern_diff[.y,.x]),.y=.x))  
  matrix(unlist(res),ncol = ncol(list_pattern_diff),byrow = T)
}
 
 
verifier_clone <- function(clone){
  ## le résultat de la fonction est un dataframe des individus différents pour au moins 2 allèles
  ## clones serie     nb individus difference
 
  ## on filtre  par le clone
  dff <- df %>% filter(clones == clone)
 
  ##on regroupe par clone les séries
  df2 <- dff %>%  group_by(clones,serie) %>% summarise(nb= n(), individus = str_c(individu,collapse = ",")) 
 
  if(max(df2$nb)<3){
    message("problème pas de clones")
  }else if(max(df2$nb == 5)){
    message(str_c(clone," ok"))
  } else{
    ## on récupère la série du clone  et la ou les 2 séries des individus différents
    pattern_clone=df2  %>% filter(nb == max(nb)) %>% pull(serie)
    pattern_diff =df2  %>% filter(nb != max(nb)) %>% ungroup()%>% select(serie)
 
 
  ## on découpe les séries en allèle
    # série ou pattern clone
  list_pattern_clone=str_split(pattern_clone,"_",simplify = T)
    # pattern individu différents
  list_pattern_diff=map(1:nrow(pattern_diff),~str_split(pattern_diff %>% slice(.x) %>% pull(serie),"_",simplify= T))
  list_pattern_diff=matrix(unlist(list_pattern_diff),nrow=length(list_pattern_diff),byrow = T)
 
  ## on remplace les manquants (*) par la valeur de l'allèle correspondant au pattern (= série) du clone
  ## pour ne pas les comptabliser comme différence
  list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)
 
  ## on génère résultat  des individus différents si différence porte sur au moins 2 allèles 
 res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
             mutate(difference = sum(is.na(str_match(list_pattern_clone,list_pattern_diff[.x,]))))) %>% filter(difference>1)
 
  }
}
 
## pour trouver tous les individus différents
resultat <- map_df(unique(df$clones),verifier_clone)

Bonjour

Un grand merci pour votre aide.

Cependant, il a des parties de votre code où je ne comprends pas

Notamment à la ligne au début ou vous écrivez

Citation:

select(-1,-2),col = "serie",names(df)[c(-1,-2)]

Code:

1
2
df <-df %>% bind_cols(unite(data=df %>% select(-1,-2),col = "serie",names(df)[c(-1,-2)],sep="_")) %>% 
  mutate(serie = str_replace_all(serie,"_NA_","_*_")) ## on mets une étoile * si donnée sur allèle est manquante

A quoi sert cette ligne ?

Code:

 individus = str_c(individu,collapse = ",")) # fusionne plusieurs vecteur en une chaine de caractère séparée par des virgules

Merci pour votre aide.

Code complet que j'ai quasiment pas modifié.

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
mydata<-read.table(file='Bilan_201905.csv', header = TRUE,sep=';')
 
unique_clone_id <- unique(mydata$clone_id)
 
## Les données manquantes doivent être remplacées par "NA" dans le fichier source.
 
## Ajout d'une colonne serie qui aggrege les allèles(=ensemble des x alleles pour un individu) 
df <-df %>% bind_cols(unite(data=df %>% select(-1,-2),col = "serie",names(df)[c(-1,-2)],sep="_")) %>% 
  mutate(serie = str_replace_all(serie,"_NA_","_*_")) ## om mets une étoile * si donnée sur allèle est manquante
 
##########################################################
### fonction qui remplace les allèles manquants par l'allèle le plus présent chez les autres clone d'un même ramet.
##########################################################
remplacer_manquant <- function(list_pattern_clone,list_pattern_diff)  {
 
  res <- map(1:nrow(list_pattern_diff),
             ~map_chr(1:ncol(list_pattern_diff),~ifelse(list_pattern_diff[.y,.x]=="*",list_pattern_clone[.x],list_pattern_diff[.y,.x]),.y=.x))  
  matrix(unlist(res),ncol = ncol(list_pattern_diff),byrow = T)
}
 
##########################################################
### fonction qui vérifie si les clones d'un ramet sont identiques ###
##########################################################
 
verifier_clone <- function(unique_clone){
 
  ## on filtre  par le clone
  filter_clones <- df %>% filter(mydata$clone_id == unique_clone)
 
  ## on regroupe par série les individus avec un numéro de clone identique.
  group_clones <- dff %>%  group_by(unique_clone,série) %>% summarise(nb= n()) 
 
    if(max(df2$nb)<3){ # si le nombre de ligne identiques est inferieur à 3
    message("erreur, le nombre de clones identiques n'est pas suffisant (<3)")
    return(unique_clone_id)
 
    }else if(max(df2$nb==5)){ # si les nombre de ligne identiques est égal à 5
    message(str_c(clone," ok, les 5 clones sont identiques"))
 
    }else{
    pattern_clone= df2  %>% filter(nb == max(nb)) %>% pull(serie) #on récupère les clones identiques
    pattern_diff = df2  %>% filter(nb != max(nb)) %>% ungroup()%>% select(serie) #on isole les clones différents
 
  ## on découpe les séries d'allèle
 
       # série d'alleles pour les bon clones (redondance>3)
    list_pattern_clone=str_split(pattern_clone,"_",simplify = T) 
 
       # série d'alleles clones différents
    list_pattern_diff=map(1:nrow(pattern_diff),~str_split(pattern_diff %>% slice(.x) %>% pull(serie),"_",simplify= T))
    list_pattern_diff=matrix(unlist(list_pattern_diff),nrow=length(list_pattern_diff),byrow = T)
 
    ## on remplace les valeurs manquantess (*) par la valeur de l'allèle correspondant au 
    ## pattern de la série des bons clone pour ne pas les comptabliser comme différence
    list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)
 
    ## On ajoute l'individu à un data.frame si la différence porte sur au moins 2 allèles 
    res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
                    mutate(difference = sum(is.na(str_match(list_pattern_clone,list_pattern_diff[.x,]))))) %>% filter(difference>1)
 
  }
}
 
## pour trouver tous les individus différents
resultat <- map_df(unique(df$clones),verifier_clone)

14/05/2019, 12h45
xavier-Pierre
bonjour

Code:

select(-1,-2),col = "serie",names(df)[c(-1,-2)]

on peut enlever

Code:

,names(df)[c(-1,-2)]

qui ne sert à rien!

Code:

individus = str_c(individu,collapse = ",")

dans la ligne de code je regroupe par clones et serie (génotype serait peut-être mieux) après je fait une aggrégation
je compte le nombre d'individu qui ont la même serie pour un clone donné et

Code:

individus = str_c(individu,collapse = ",")

me donne sous forme de string la liste de ces individus
Code:

1 2 3 num_ind<-c(1,2,3) list_num_ind<-str_c(num_ind, collapse = "_") ## donne "1_2_3"
14/05/2019, 14h20
ehones4

Bonjour,

En réalité, c'est pas que je ne comprend pas les fonction utilisées, c'est plutot que je ne vois pas toujours vers où vous allez, et pourquoi vous faite ceci ou cela.

Par exemple, je ne comprend pas pourquoi faite

Citation:

select(-1,-2]

. Il n'y a pas de telles valeurs dans le data.frame.
Je ne comprend pas non plus a quoi sert

Code:

individus = str_c(individu,collapse = ",")

puisque vous ne le réutilisez pas dans la suite du code, sauf erreur de ma part.

ok, on s'était mal compris

Code:

df%>%select(-1,-2)

un particularité de la fonction select : elle permet de sélectionner les colonnes soit par leur nom soit par leur indice donc
Code:

1 2 3 4 5 6 7 8 df%>%select(clones, individus) ## selection uniquemement des colonnes clones et individu du dataframe df # est équivalent à df%>%select(1,2) ## on suppose comme dans ton exemple que ce sont les 2 premières colonnes de df # quand on met des nombres négatifs on sélectionne toutes les colonnes sauf la une et la deux ]df%>%select(-1,-2) ##ou df%>% select(-clones, -individus) # on sélectionne toutes les colonnes (tous les alleles dans ton cas) sauf les colonnes clones et individu ##après avec la fonction unite je crée une colonne serie qui est l'aggrégation de tous les allèles sous forme de string, les alleles étant séparé par un underscore
Code:

resultat <- map_df(unique(df$clones),verifier_clone)

le dataframe resultat a 4 colonnes
clones ## nom du clone étudié
serie ## serie de l'individu différent
individus ## le numero de l'individu different obtenu par

Code:

individus = str_c(individu,collapse = ",")

difference ## nombre de différence avec la serie "clone"

si tu teste avec le petit exemple que tu as donné tu obtiens un dataframe resultat vide car le seul individu différent n'a qu'une différence (tu veux au moin 2) , si tu mets en commentaire

Code:

%>% filter(difference>1

dans la dernière ligne de code de la fonction verifier_clone()
tu obtiens le dataframe suivant

clones serie ; nb ;individus; difference

clone1; A_T_AT; 1 ;4 ; 1

j'espère que c'est plus clair

Bonjour,

Oui merci pour ces explications, c'est beaucoup plus clair pour moi désormais.
Par contre j'ai un message d'erreur, c'est du chinois :

Citation:

Error in stri_match_first_regex(string, pattern, opts_regex = opts(pattern)) :
Syntax error in regexp pattern. (U_REGEX_RULE_SYNTAX)
In addition: Warning message:
Hide Traceback

Rerun with Debug
Error in stri_match_first_regex(string, pattern, opts_regex = opts(pattern)) :
Syntax error in regexp pattern. (U_REGEX_RULE_SYNTAX)

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
 
##########################################################
### LOAD PACKAGE ###
##########################################################
library(tidyverse)
 
##########################################################
### IMPORT DATA ###
##########################################################
 
df<-read.table(file='Bilan.csv', header = TRUE,sep=';')
 
## Les données manquantes doivent être remplacées par "NA" dans le fichier source.
 
## Ajout d'une colonne serie qui aggrège les allèles (=ensemble des x alleles pour un individu) 
df <- df %>% bind_cols(unite(data=df %>% select(-1,-2),col = "serie",sep="_")) %>%  
  mutate(serie = str_replace_all(serie,"NA_","*_")) ## on mets une étoile * si donnée sur allèle est manquante
 
##########################################################
### fonction qui remplace les allèles manquants par l'allèle le plus présent chez les autres clone d'un même ramet.
##########################################################
 
remplacer_manquant <- function(list_pattern_clone,list_pattern_diff)  {
 
  res <- map(1:nrow(list_pattern_diff),
             ~map_chr(1:ncol(list_pattern_diff),~ifelse(list_pattern_diff[.y,.x]=="*",list_pattern_clone[.x],list_pattern_diff[.y,.x]),.y=.x))  
  matrix(unlist(res),ncol = ncol(list_pattern_diff),byrow = T)
}
 
##########################################################
### fonction qui vérifie si les clones d'un ramet sont identiques ###
##########################################################
 
verifier_clone <- function(clone){
 
  ## on filtre  par le clone
  dff <- df %>% filter(df$clone_id == clone)
 
  ## on regroupe par série d'allèle les individus avec un numéro de clone identique.
  df2 <- dff %>%  group_by(dff$clone_id,serie) %>% summarise(nb= n(), individus = str_c(SAMPLE_NAME,collapse = ","))
 
    if(max(df2$nb)<3){ # si le nombre de ligne (série allele) identiques est inferieur à 3
    message("erreur, le nombre de clones identiques n'est pas suffisant (<3). L'analyse doit être faite à la main")
    print(clone)
 
    }else if(max(df2$nb==5)){ # si les nombre de ligne (série allele) identiques est égal à 5
    message(str_c(clone," ok, les 5 clones du ramet sont identiques"))
 
    }else{
    pattern_clone= df2  %>% filter(nb == max(nb)) %>% pull(serie) #on récupère les clones identiques
    pattern_diff = df2  %>% filter(nb != max(nb)) %>% ungroup()%>% select(serie) #on isole les clones différents
 
  ## on découpe les séries d'allèles
 
       # série d'alleles pour les bon clones (redondance>3)
    list_pattern_clone=str_split(pattern_clone,"_",simplify = T) 
 
       # série d'alleles clones différents
    list_pattern_diff=map(1:nrow(pattern_diff),~str_split(pattern_diff %>% slice(.x) %>% pull(serie),"_",simplify= T))
    list_pattern_diff=matrix(unlist(list_pattern_diff),nrow=length(list_pattern_diff),byrow = T)
 
    ## on remplace les valeurs manquantess (*) par la valeur de l'allèle correspondant au 
    ## pattern de la série des bons clone pour ne pas les comptabliser comme différence
    list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)
 
    ## On ajoute l'individu à un data.frame si la différence porte sur au moins 2 allèles 
    res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
                    mutate(difference = sum(is.na(str_match(list_pattern_clone,list_pattern_diff[.x,]))))) %>% filter(difference>1)
 
  }
}
 
## pour trouver tous les individus différents
resultat <- map_df(unique(df$clone_id),verifier_clone)
 
##########################################################
### lexique des fonctions ###
##########################################################
 
# bind_cols = permet d’ajouter des colonnes à une table à partir d’une ou plusieurs autres tables.
# summurize() = fusionne plusieurs vecteur en une chaine de caractère séparée par des virgules. L'argument 'n()' retourne le nombre de lignes du groupe.
# map() = transforme l'input en appliquant une fonction à chaque élément et retourne un vecteur de la même longueur que l'input.
# str_split() = découpe une chaine de caractère en caractère uniques. Simplify = T permet de retourner une matrice.
# unite() = Convenience function to paste together multiple columns into one.

14/05/2019, 16h06
xavier-Pierre

est ce que vous avez des caractères spéciaux dans les valeurs de vos allèles : + [] }{ ...
14/05/2019, 16h15
ehones4

Seulement des '_', les tirets du 8 pour la première ligne (nom des alleles)
Des tirets du 6 pour le nom des clones dans la première colonne

Et sinon, c'est juste des A, T, C, G ou NA pour les alleles.

Si vous souhaitez jeter un coup d'oeil au jeu de donnée, le voici :
https://drive.google.com/file/d/1HDx...ew?usp=sharing

bonjour je n'ai reproduit votre erreur quand mettant des caractères spéciaux du type { , dans les valeurs des allèles

j'ai fait un changement dites moi si ça résoud le problème

Code:

1
2
3
4
5
6
7
8
9
 
## dans la fonction verifier_clone changer la derniere instruction
res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
                    mutate(difference = sum(is.na(str_match(list_pattern_clone,list_pattern_diff[.x,]))))
 
## par 
 
res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
                    mutate( difference =sum(!str_detect(list_pattern_clone,fixed(list_pattern_diff[.x,])))))

en espérant que cela fonctionne
autrement il y 2 autres modifs à faire

Code:

1
2
3
4
5
6
7
8
9
10
 
## première modif dans la fonction verifer_clone
  if(max(df2$nb)<3){ # si le nombre de ligne (série allele) identiques est inferieur à 3
    message("erreur, le nombre de clones identiques n'est pas suffisant (<3). L'analyse doit être faite à la main")
    print(clone)  
    return()   ## a RAJOUTER
 
##deuxième modif pour remplacer les NA par * ,enlever l' underscore
df <- df %>% bind_cols(unite(data=df %>% select(-1,-2),col = "serie",sep="_")) %>%  
  mutate(serie = str_replace_all(serie,"NA","*")) ## on mets une étoile * si donnée sur allèle est manquante

Bonjour,

J'ai toujours un message d'erreur, different cette fois

Code:

Error in list_pattern_diff[.y, .x] : subscript out of bounds

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
df<-read.table(file='Bilan.csv', header = TRUE,sep=';')
 
## Les données manquantes doivent être remplacées par "NA" dans le fichier source.
 
## Ajout d'une colonne serie qui aggrège les allèles (=ensemble des x alleles pour un individu) 
df <- df %>% bind_cols(unite(data=df %>% select(-1,-2),col = "serie",sep="_")) %>%  
  mutate(serie = str_replace_all(serie,"NA","*")) ## on mets une étoile * si donnée sur allèle est manquante
 
##########################################################
### fonction qui remplace les allèles manquants par l'allèle le plus présent chez les autres clone d'un même ramet.
##########################################################
 
remplacer_manquant <- function(list_pattern_clone,list_pattern_diff)  {
 
  res <- map(1:nrow(list_pattern_diff),
             ~map_chr(1:ncol(list_pattern_diff),~ifelse(list_pattern_diff[.y,.x]=="*",list_pattern_clone[.x],list_pattern_diff[.y,.x]),.y=.x))  
  matrix(unlist(res),ncol = ncol(list_pattern_diff),byrow = T)
}
 
##########################################################
### fonction qui vérifie si les clones d'un ramet sont identiques ###
##########################################################
 
verifier_clone <- function(clone){
 
  ## on filtre  par le clone
  dff <- df %>% filter(df$clone_id == clone)
 
  ## on regroupe par série d'allèle les individus avec un numéro de clone identique.
  df2 <- dff %>%  group_by(dff$clone_id,serie) %>% summarise(nb= n(), individus = str_c(SAMPLE_NAME,collapse = ","))
 
    if(max(df2$nb)<3){ # si le nombre de ligne (série allele) identiques est inferieur à 3
    message("erreur, le nombre de clones identiques n'est pas suffisant (<3).")
    print(clone)
    return()
 
    }else if(max(df2$nb==5)){ # si les nombre de ligne (série allele) identiques est égal à 5
    message(str_c(clone," ok, les 5 clones du ramet sont identiques"))
 
    }else{
    pattern_clone= df2  %>% filter(nb == max(nb)) %>% pull(serie) #on récupère les clones identiques
    pattern_diff = df2  %>% filter(nb != max(nb)) %>% ungroup()%>% select(serie) #on isole les clones différents
 
  ## on découpe les séries d'allèles
 
       # série d'alleles pour les bon clones (redondance>3)
    list_pattern_clone=str_split(pattern_clone,"_",simplify = T) 
 
       # série d'alleles clones différents
    list_pattern_diff=map(1:nrow(pattern_diff),~str_split(pattern_diff %>% slice(.x) %>% pull(serie),"_",simplify= T))
    list_pattern_diff=matrix(unlist(list_pattern_diff),nrow=length(list_pattern_diff),byrow = T)
 
    ## on remplace les valeurs manquantes (*) par la valeur de l'allèle correspondant au 
    ## pattern de la série des bons clone pour ne pas les comptabliser comme différence
    list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)
 
    ## On ajoute l'individu à un data.frame si la différence porte sur au moins 2 allèles 
    res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
                    mutate( difference =sum(!str_detect(list_pattern_clone,fixed(list_pattern_diff[.x,])))))  
  }
}
 
## pour trouver tous les individus différents
resultat <- map_df(unique(df$clone_id),verifier_clone)
 
##########################################################
### lexique des fonctions ###
##########################################################

Merci de votre aide

15/05/2019, 11h12
xavier-Pierre
Je n'arrive pas à reproduire l'erreur , à priori elle arrive dans la fonction remplacer_manquant

dans la fonction verifier_clone juste avant la ligne :

Code:

list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)

ajouter un print(clone).

et dans la fonction remplacer_manquant mettre en début
Code:

1 2 print(list_pattern_clone) print(list_pattern_diff)
et regarder en particulier list_pattern_diff

Pour vous le script fonctionne avec mon jeu de données?
Etrange..

Citation:

dans la fonction verifier_clone juste avant la ligne :list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)
ajouter un print(clone)

Les numéros de clones sont bien affichés dans la console.

Citation:

et dans la fonction remplacer_manquant mettre en début
print(list_pattern_clone)

Cela retourne des séries d’allèles dans la console.

Citation:

et regarder en particulier list_pattern_diff

Même chose.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14] [,15] [,16] [,17] [,18]
[1,] "GT" "G"  "CG" "CT" "G"  "C"  "T"  "GA" "T"  "A"   "T"   "TC"  "G"   "A"   "CA"  "T"   "GT"  "CT" 
     [,19] [,20] [,21] [,22] [,23] [,24] [,25] [,26] [,27] [,28] [,29] [,30] [,31] [,32] [,33] [,34]
[1,] "GA"  "A"   "T"   "GA"  "CT"  "CT"  "G"   "T"   "CT"  "GC"  "A"   "GA"  "CT"  "C"   "C"   "A"  
     [,35] [,36] [,37] [,38] [,39] [,40] [,41] [,42] [,43] [,44] [,45] [,46] [,47] [,48] [,49] [,50]
[1,] "A"   "G"   "C"   "G"   "G"   "A"   "G"   "TC"  "GA"  "CT"  "A"   "T"   "A"   "CA"  "TC"  "AG" 
     [,51] [,52] [,53] [,54] [,55] [,56] [,57] [,58] [,59] [,60] [,61] [,62]
[1,] "GA"  "A"   "T"   "A"   "AG"  "CG"  "C"   "GT"  "G"   "GA"  "TA"  "G"  
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14] [,15] [,16] [,17] [,18]
[1,] "GT" "GC" "CG" "CT" "G"  "C"  "TC" "G"  "T"  "G"   "CT"  "TC"  "GC"  "TA"  "A"   "T"   "GT"  "C"  
     [,19] [,20] [,21] [,22] [,23] [,24] [,25] [,26] [,27] [,28] [,29] [,30] [,31] [,32] [,33] [,34]
[1,] "GA"  "CA"  "G"   "GA"  "C"   "CT"  "GA"  "G"   "CT"  "GC"  "AT"  "GA"  "C"   "T"   "CA"  "C"  
     [,35] [,36] [,37] [,38] [,39] [,40] [,41] [,42] [,43] [,44] [,45] [,46] [,47] [,48] [,49] [,50]
[1,] "T"   "GT"  "TC"  "G"   "A"   "T"   "A"   "TC"  "GA"  "T"   "G"   "TC"  "A"   "CA"  "TC"  "AG" 
     [,51] [,52] [,53] [,54] [,55] [,56] [,57] [,58] [,59] [,60] [,61] [,62]
[1,] "GA"  "CA"  "AT"  "TA"  "A"   "G"   "CT"  "G"   "G"   "A"   "TA"  "GC"

Sauf qu'a la fin, il y a deux lignes vides:

Code:

1
2
[1,]
[2,]

15/05/2019, 14h32
xavier-Pierre

Citation:

Pour vous le script fonctionne avec mon jeu de données?
Etrange..

non je n'ai pas votre jeu de données réel, je teste avec un jeu de données fictif en essayant de lister tous les cas possibles , mais là
je ne vois pas l'erreur, si vous pouvez m'envoyer votre jeu de donnée , je peux tenter de voir le problème, si vous ne pouvez pas ce que je comprends désolé...
15/05/2019, 14h49
ehones4

Vous pouvez télécharger le jeu de données grâce à ce lien :
https://drive.google.com/file/d/1HDx...xGIuD3Kd2/view

Merci infiniment pour votre aide.

ok , j'ai compris j'étais parti du principe qu'il y avait toujours 5 individus par clone mais en fin de compte le nombre varie de 1 à 10
j'ai corrigée l'erreur dans la fonction verifier_clone il faut changer la ligne

Code:

1
2
3
4
5
 
else if(max(df2$nb)==5){ # si les nombre de ligne (série allele) identiques est égal à 5
## par
else if(max(df2$nb)==nrow(dff)){ # si les nombre de ligne (série allele) identiques pour tous les individus
return() ## inutile de continuer la suite de la fonction

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
library(tidyverse)
## Les données manquantes doivent être remplacées par "NA" dans le fichier source.
rm(list=ls())
 
#df <- read_csv2("d:/tempo/clones_reel.csv",col_types =cols(.default = 'c'))
df <- read.table("d:/tempo/clones_reel.csv", header = TRUE,sep=';')  ## METTRE VOTRE CHEMIN ET FICHIER
 
## Ajout d'une colonne serie qui aggrège les allèles (=ensemble des x alleles pour un individu) 
df <- df %>% bind_cols(unite(data=df %>% select(-1,-2),col = "serie",sep="_")) %>%  
  mutate(serie = str_replace_all(serie,"NA","*")) ## on mets une étoile * si donnée sur allèle est manquante
 
 
 
 
##########################################################
### fonction qui remplace les allèles manquants par l'allèle le plus présent chez les autres clone d'un même ramet.
##########################################################
 
remplacer_manquant <- function(list_pattern_clone,list_pattern_diff)  {
  # print(str_c("list_pattern_clone", list_pattern_clone))
  # print(rep("****",6))
  # print(str_c("list_pattern_diff : ",list_pattern_diff))
  res <- map(1:nrow(list_pattern_diff),
             ~map_chr(1:ncol(list_pattern_diff),~ifelse(list_pattern_diff[.y,.x]=="*",list_pattern_clone[.x],list_pattern_diff[.y,.x]),.y=.x))  
  matrix(unlist(res),ncol = ncol(list_pattern_diff),byrow = T)
}
 
##########################################################
### fonction qui vérifie si les clones d'un ramet sont identiques ###
##########################################################
 
verifier_clone <- function(clone){
 
  ## on filtre  par le clone
  dff <- df %>% filter(df$clone_id == clone)
 
  ## on regroupe par série d'allèle les individus avec un numéro de clone identique.
  df2 <- dff %>%  group_by(clone_id,serie) %>% summarise(nb= n(), individus = str_c(SAMPLE_NAME,collapse = ","))
 
  if(max(df2$nb)<3){ # si le nombre de ligne (série allele) identiques est inferieur à 3
    message("erreur, le nombre de clones identiques n'est pas suffisant (<3).")
    print(clone)
    return()
 
  }else if(max(df2$nb)==nrow(dff)){ # si les nombre de ligne (série allele) identiques est égal à 5
    message(str_c(clone," ok, les" ,ncol(df2)," clones du ramet sont identiques"))
    return()
  }else{
    pattern_clone= df2  %>% filter(nb == max(nb)) %>% pull(serie) #on récupère les clones identiques
    pattern_diff = df2  %>% filter(nb != max(nb)) %>% ungroup()%>% select(serie) #on isole les clones différents
 
    ## on découpe les séries d'allèles
 
    # série d'alleles pour les bon clones (redondance>3)
    list_pattern_clone=str_split(pattern_clone,"_",simplify = T) 
 
    # série d'alleles clones différents
    list_pattern_diff=map(1:nrow(pattern_diff),~str_split(pattern_diff %>% slice(.x) %>% pull(serie),"_",simplify= T))
    list_pattern_diff=matrix(unlist(list_pattern_diff),nrow=length(list_pattern_diff),byrow = T)
 
    ## on remplace les valeurs manquantes (*) par la valeur de l'allèle correspondant au 
    ## pattern de la série des bons clone pour ne pas les comptabliser comme différence
    print(str_c("CLONE: ",clone))
    list_pattern_diff =remplacer_manquant(list_pattern_clone,list_pattern_diff)
 
    ## On ajoute l'individu à un data.frame si la différence porte sur au moins 2 allèles 
    res <- map_df(1:nrow(list_pattern_diff),~df2 %>% filter(serie == str_c(list_pattern_diff[.x,],collapse ="_")) %>% 
                    mutate( difference =sum(!str_detect(list_pattern_clone,fixed(list_pattern_diff[.x,])))))  %>% 
      filter(difference>1)
  }
}
 
## pour trouver tous les individus différents
resultat <- map_df(unique(df$clone_id),verifier_clone)

après vous voyez si la règle des 3 individus mini pour caractériser le phénotype d'un clone suffit ,que faire des clones entre 1 et 3 individus
vous avez peut-être aussi intérêt à récuperer les identifiants des clones complets et ceux qui n'ont pas 3 individus mini et pas uniquement une alerte

Bonjour,

Après relecture, je constate (pour plusieurs raisons) qu'il serait préférable de d'abord compléter les valeurs manquantes, avant de comparer les génotypes.
J'ai commencé a écrire un script équivalent à remplacer_manquant, qui compare les allèles colonne par colonne (ce qui est différent des séries agrégeant les alleles dans script que vous m'aviez fourni).

Sans trop de surprises, cela ne fonctionne pas, je ne sais pas ce qui cloche :

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
library(tidyverse)
 
remplacer_manquant <- function(clone){
 
  dff <- df %>% filter(df$clone_id == clone) # on sélectionne le numéro de clone voulu, et les individus.
 
  for (col in 3:ncol(df)){ # nb : '3' car les deux premières colonnes de dff ne sont pas des alleles
 
    t <- as.data.frame(table(df[,col])) #création d'un tableau de correspondance, qui nous donne l'occurence des différents allele pour un snp donné.
    max_t <= max(t$Freq) # on extrait le nombre de fois ou l'allele le plus représenté apparait dans la colonne.
    allele_majoritaire <- as.character(t$Var1[which(t$Freq==max_t)]) # on extrait les charactères alphabétiques de l'allele
 
    if (max_t>3){ # si l'allele apparait au moins 3 fois
      res <- df %>% filter(df$clone_id == clone) %>% mutate_at(df[,col], ~replace_na(df, allele_majoritaire))
      return()
 
    }else{
      message(c(message = 'le numéro de clone ',clone, message =' n a pas assez de SNPs identiques pour compléter les NAs'))
      return()
    }
  }
}
 
resultat <- remplacer_manquant(unique(clone_id))

Merci

17/05/2019, 07h09
xavier-Pierre

bonjour,
pour remplacer toutes les valeurs NA dans un dataframe:

Code:

data[is.na(data)] <- "*"
17/05/2019, 08h35
ehones4

Bonjour, merci pour votre réponse.

J'avais testé cette fonction qui marche bien. Le seul soucis c'est que cela s'applique a tout le data.frame.

Je souhaite remplacer les NAs colonne par colonne, dans ma boucle for col.
J'ai testé ceci :

Code:

data[is.na(data[,col])] <- "*"

Ca ne plante pas, mais le résultat n'est pas du tout celui attendu.

edit : J'ai trouvé la solution :

Code:

df[,col][is.na(df[,col])] <- allele_majoritaire

J'ai un petit peu avancé sur ma fonction mais je rencontre un soucis.
Ma boucle ne tourne pas, et je ne comprend pas pourquoi

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
 
##########################################################
### fonction qui remplace les valeurs manquantes
##########################################################
library(tidyverse)
 
remplacer_manquant <- function(clone){
 
  df_diff = data.frame()
  print(df_diff) 
 
for (i in clone){
 
  print(i)
  pattern_clone = NULL 
  print(pattern_clone)
 
  for (col in 3:ncol(df)){ # nb : '3' car les deux premières colonnes de dff ne sont pas des alleles
 
    t <- as.data.frame(table(df[,col][which(df$clone_id==i)])) #création d'un tableau de correspondance, qui nous donne l'occurence des différents allele pour un snp donné.
    print(t)
    max_t = max(t$Freq) # on extrait le nombre de fois ou l'allele le plus représenté apparait dans la colonne.
    print(max_t)
    allele_majoritaire <- as.character(t$Var1[which(t$Freq==max_t)]) # on extrait les charactères alphabétiques de l'allele
    print(allele_majoritaire)
 
    if (max_t>3){ # si l'allele apparait au moins 3 fois
      # on remplace les NAs par l'allele majoritaire
      df[,col][is.na(df[,col])] <- allele_majoritaire
      View(df)
      #création d'un pattern génotype de référence pour comparer les génotypes dans l'étape suivante
      pattern_clone <- append(pattern_clone, allele_majoritaire)
      print(pattern_clone)
      return()
 
    }else{
      message(c(message = 'le numéro de clone ',i, message =' n a pas assez de SNPs identiques pour compléter les NAs'))
      pattern_clone <- append(pattern_clone, NA)
      return(df_diff)
    }
    }
}
}
 
resultat <- remplacer_manquant(unique(df$clone_id))