1. Installation et découverte de R
Qu'est-ce que le logiciel R ? Comment l'installer, sur Windows, MacOs, Linux ?
R est un logiciel statistique général gratuit. Il se compose de commandes et d'un langage de programmation. Ce dernier fournit à R toute sa richesse : de nombreux utilisateurs et professionnels mettent à disposition sur le Web leurs données, leurs programmes et des textes d'aides regroupés sous forme de packages. Il y avait en août 2013 aux environs de 4750 packages disponibles, plus de 5400 début avril 2014 et 6685 en mai 2015.
La liste des packages R est à l'adresse available_packages. Nous verrons plus tard comment nous y retrouver.
La richesse et la qualité des graphiques produits par R en font un logiciel de présentation de données incomparable et non pas uniquement un logiciel statistique.
R est un logiciel très complet : il permet de traiter aussi bien des données génomiques que médicales, économiques, géographiques, écologiques, biochimiques...
De plus le projet bioconductor qui traite de bioinformatique et de données génomiques, dont celles issues de puces à ADN et autres technologies NGS, est basé sur R. Il possède des propres packages, soit en gros 1500 packages supplémentaires (août 2013), 2150 en 2015. La liste complémentaires des packages R pour bioconductor est à l'adresse BiocViews.
Pour installer R, il suffit de se rendre sur le site officiel nommé CRAN et de télécharger l'exécutable correspondant au système d'exploitation souhaité (Windows, MacOs, Unix). Pour Linux (Ubuntu), une page spéciale explique comment installer R via sudo apt-get.
Le CRAN est une partie du site officiel de R nommé R-project qui dispose de nombreux sites mirroirs dans le monde entier.
2. Mode interactif, sessions et mode batch
Quel est la différence entre le mode interactif et le mode batch ?
Expliquer ce que fait chaque instruction du fichier ci-dessous si l'on exécute dans une session R. Les numéros de ligne ne font pas partie des instructions. Il y a des lignes vides.
01 v <- 1:10
02 mean(v)
03
04 print( mean(v) )
05 ( mean(v) )
06 moyv <- mean(v) # stockage
07
08 mean( x=c(1:10,15:18), trim=0.5)
09 x <- 1 ; y <- x + 1 ; x <- x + 3
10
11 quit()
Il y a deux mode principaux d'utilisation de R : le mode interactif et le mode traitement par lots ou batch. En mode interactif, on tape une commande et R répond. On tape alors une autre commande et R répond à nouveau, etc. En mode traitement par lots, on fournit à R un ensemble de commandes à exécuter et R les traite les unes à la suite des autres. Il est aussi possible, en mode interactif, d'exécuter des paquets d'instructions...
Les lignes vides ne servent à rien en session interactive puisque R n'en fait rien. Par contre en mode batch, cela peut servir à aérer le texte des instructions, des résultats...
La ligne 1 réalise une affectation. 1:10 est la suite des entiers de 1 à 10 et R met ces valeurs dans la variable v, ce qui en fait un vecteur, dans la terminologie de R (il ne s'agit pas exactement de la notion de vecteur comme en mathématique, mais cela y ressemble fortement). On ne voit rien de plus à l'écran car il s'agit d'une affectation en mémoire.
La ligne 2 effectue le calcul de la moyenne arithmétique de v à l'aide de la fonction mean(). Comme il n'y a pas d'affectation, en mode interactif, R affiche le résultat. En mode batch, suivant les options, la moyenne est ou n'est pas affichée.
La ligne 4 effectue le calcul de la moyenne arithmétique de v et demande explicitement à R d'afficher ce résultat. Quel que soit le mode, la moyenne est donc affichée.
La ligne 5 effectue le calcul de la moyenne arithmétique de v et les parenthèses forcent R à afficher ce résultat en mode interactif. C'est plus court à écrire que la ligne 4.
La ligne 6 effectue le calcul de la moyenne arithmétique de v et met le résultat dans la variable nommée meanv. Il est conseillé d'utiliser des noms (ou "identificateurs") d'au moins 3 lettres et, si possible, explicite. Dans cette ligne 6, le symbole # (dièse) et ce qui suit est un commentaire et est ignoré par R. Il est conseillé de commenter et de documenter son code R pour pouvoir le relire, comme par exemple sdcv <- sum( v*v ) # sdcv = somme des carrés des valeurs.
La ligne 8 effectue le calcul de la moyenne arithmétique tronquée du vecteur indiqué entre parenthèses avec un écrémage de 50 % (aucune importance si vous ne comprenez pas ce que cela veut dire, c'est juste pour l'exemple, nous y reviendrons). Les deux arguments de la fonction mean() ont été nommés pour faciliter la lecture de l'instruction. Il aurait été possible d'écrire mean( c(1:10,15:18), 0.5 ) afin d'obtenir le même résultat mais de façon moins compréhensible. c(1:10,15:18) affectue la concaténation des deux vecteurs 1:10 et 15:18, c'est-à-dire que R en fait un seul vecteur en les mettant bout à bout.
La ligne 9 effectue plusieurs calculs en mémoire sur une même ligne, ce qui n'est pas très conseillé. La variable x prend la valeur 1, puis y prend la valeur 2 (via le calcul x+1) et enfin x est incrémenté de 3, c'est-à-dire augmenté de 3. x vaut donc 4. Mais R n'affiche rien.
La ligne 11 permet de quitter R. Nous avons répondu y pour yes afin de sauvegarder ce que nous avons créé.
Voici une copie de l'exécution des commandes avec les réponses éventuelles de R :
R version 3.0.1 (2013-05-16) -- "Good Sport"
Copyright (C) 2013 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)
R est un logiciel libre livré sans AUCUNE GARANTIE.
Vous pouvez le redistribuer sous certaines conditions.
Tapez 'license()' ou 'licence()' pour plus de détails.
R est un projet collaboratif avec de nombreux contributeurs.
Tapez 'contributors()' pour plus d'information et
'citation()' pour la façon de le citer dans les publications.
Tapez 'demo()' pour des démonstrations, 'help()' pour l'aide
en ligne ou 'help.start()' pour obtenir l'aide au format HTML.
Tapez 'q()' pour quitter R.
> v <- 1:10
> mean(v)
[1] 5.5
>
> print( mean(v) )
[1] 5.5
> ( mean(v) )
[1] 5.5
> moyv <- mean(v) # stockage
>
> mean( x=c(1:10,15:18), trim=0.5)
[1] 7.5
> x <- 1 ; y <- x + 1 ; x <- x + 1
> quit()
Save workspace image? [y/n/c]: y
3. Structures de données et affichages
Quelles sont les structures de données en R ? Comment fait-on pour ne voir que le début des données, ou la fin ?
Comment sauvegarder des variables de session ?
Les principales structures de données sont les vecteurs, les matrices, les listes et les data frames. Toutes les variables sont des objets et tout est objet, y compris les fonctions que l'on peut créer. Pour créer une variable, on utilise soit une fonction explicite, comme <-, c(), vector() ou matrix(), soit une des notations ou une des conversions automatiques de R.
De façon simpliste, un vecteur et une liste ont une longueur alors qu'une matrice et un data frame ont deux dimensions, à savoir le nombre de lignes (row en anglais) et le nombre de colonnes (column en anglais). Les fonctions associées sont length(), dim(), nrow() et ncol().
La fonction c() permet de concaténer des valeurs pour en faire un vecteur, mais on peut la mémoriser en imaginant que c() signifie construire ou créer. La fonction rep() crée un vecteur par répétition alors que la fonction seq() produit un vecteur par séquence. La notation : (le symbole deux-points) en est un résumé pour les paramètres standards.
La notation en crochets droits [ et ] permet de sélectionner des lignes ou des groupes de lignes et des colonnes ou des groupes de colonnes. La fonction head() affiche le début d'une structure alors que tail() en affiche la fin.
Voici une démonstration de toutes ces fonctions (vous pouvez copier/coller le texte du cadre bleu pour obtenir ce qu'il y a dans le cadre jaune) :
# un vecteur des trois valeurs 10, 50 et 35
print( v1 <- c(10,50,35) )
# la fonction c() crée aussi des vecteurs de chaines
( v2 <- c("oui","non") )
# le nombre d'éléments d'un vecteur est appelé sa longueur
print( length(v1) )
# avec la fonction cat() on peut affiner l'affichage
# et \n saute à la ligne
cat("\n le vecteur v1 contient ",length(v1)," éléments.\n")
# la notation deux points crée une "séquence"
( v3 <- 1:10 )
# qui est identique à ce que fait la fonction seq()
v4 <- seq(1,10) # mais seq(from=1,to=10) est plus lisible
print( identical(v3,v4) )
# avec rep(), on répéte une valeur n fois
v5 <- rep(0,10) # le vecteur nul en taille 10
# avec seq on peut aller de 10 en 10 :
( seq(260,325,10) )
# on crée une matrix de 5 lignes, 3 colonnes avec que des
# zéros :
( m1 <- matrix( rep(0,15), nrow=5, ncol=3) )
# mais R est capable de "recycler" les valeurs donc
# il est plus court d'écrire
( m2 <- matrix( 0, nrow=5, ncol=3) )
# une matrice des nombres de 1 à 12 sur 4 lignes
( m3 <- matrix( 1:12, nrow=4) )
# pour forcer le remplissage en ligne, on utilise le paramètre byrow
( m4 <- matrix( 1:12, nrow=4, byrow=TRUE) )
# nrow() et ncol() sont des fonctions
cat(" m4 comporte ",nrow(m4)," lignes et ",ncol(m4)," colonnes ")
# soit encore :
print( dim(m4) )
# head() et tail() s'adresse aux vecteurs et aux matrices
print( head( 1:100) ) # par défaut les 6 premiers
print( tail( 1:100) ) # par défaut les 6 derniers
print( tail( 1:100,n=3) ) # les 3 derniers
print( head(m4, n=1 ) ) # la première ligne
# la notation en crochets permet de préciser ce qu'on veut
maMat <- m4
print( maMat[1,3] ) # l'élément en ligne 1 colonne 3
print( maMat[1:2,3] ) # les éléments en colonne 3 des lignes 1 et 2
print( maMat[(1:2),3] ) # idem mais plus lisible car moins ambigu pour débutant(e)
print( maMat[1:2,c(1,3)] ) # à votre avis ?
print( maMat[1,] ) # la ligne 1
print( maMat[,2] ) # la colonne 2
print( maMat[,2,drop=FALSE] ) # la colonne 2 sans perdre la structure de matrice
> # un vecteur des trois valeurs 10, 50 et 35
>
> print( v1 <- c(10,50,35) )
[1] 10 50 35
> # la fonction c() crée aussi des vecteurs de chaines
>
> ( v2 <- c("oui","non") )
[1] "oui" "non"
> # le nombre d'éléments d'un vecteur est appelé sa longueur
>
> print( length(v1) )
[1] 3
> # avec la fonction cat() on peut affiner l'affichage
> # et \n saute à la ligne
>
> cat("\n le vecteur v1 contient ",length(v1)," éléments.\n")
le vecteur v1 contient 3 éléments.
> # la notation deux points crée une "séquence"
>
> ( v3 <- 1:10 )
[1] 1 2 3 4 5 6 7 8 9 10
> # qui est identique à ce que fait la fonction seq()
>
> v4 <- seq(1,10) # mais seq(from=1,to=10) est plus lisible
> print( identical(v3,v4) )
[1] TRUE
> # avec rep(), on répéte une valeur n fois
>
> v5 <- rep(0,10) # le vecteur nul en taille 10
> # avec seq on peut aller de 10 en 10 :
>
> ( seq(260,325,10) )
[1] 260 270 280 290 300 310 320
> # on crée une matrix de 5 lignes, 3 colonnes avec que des
> # zéros :
>
> ( m1 <- matrix( rep(0,15), nrow=5, ncol=3) )
[,1] [,2] [,3]
[1,] 0 0 0
[2,] 0 0 0
[3,] 0 0 0
[4,] 0 0 0
[5,] 0 0 0
> # mais R est capable de "recycler" les valeurs donc
> # il est plus court d'écrire
>
> ( m2 <- matrix( 0, nrow=5, ncol=3) )
[,1] [,2] [,3]
[1,] 0 0 0
[2,] 0 0 0
[3,] 0 0 0
[4,] 0 0 0
[5,] 0 0 0
> # une matrice des nombres de 1 à 12 sur 4 lignes
>
> ( m3 <- matrix( 1:12, nrow=4) )
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
> # pour forcer le remplissage en ligne, on utilise le paramètre byrow
>
> ( m4 <- matrix( 1:12, nrow=4, byrow=TRUE) )
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
[4,] 10 11 12
> # nrow() et ncol() sont des fonctions
>
> cat(" m4 comporte ",nrow(m4)," lignes et ",ncol(m4)," colonnes ")
m4 comporte 4 lignes et 3 colonnes
> # soit encore :
>
> print( dim(m4) )
[1] 4 3
> # head() et tail() s'adresse aux vecteurs et aux matrices
>
> print( head( 1:100) ) # par défaut les 6 premiers
[1] 1 2 3 4 5 6
> print( tail( 1:100) ) # par défaut les 6 derniers
[1] 95 96 97 98 99 100
> print( tail( 1:100,n=3) ) # les 3 derniers
[1] 98 99 100
> print( head(m4, n=1 ) ) # la première ligne
[,1] [,2] [,3]
[1,] 1 2 3
> # la notation en crochets permet de préciser ce qu'on veut
>
> maMat <- m4
> print( maMat[1,3] ) # l'élément en ligne 1 colonne 3
[1] 3
> print( maMat[1:2,3] ) # les éléments en colonne 3 des lignes 1 et 2
[1] 3 6
> print( maMat[(1:2),3] ) # idem mais plus lisible car moins ambigu pour débutant(e)
[1] 3 6
> print( maMat[1:2,c(1,3)] ) # à votre avis ?
[,1] [,2]
[1,] 1 3
[2,] 4 6
> print( maMat[1,] ) # la ligne 1
[1] 1 2 3
> print( maMat[,2] ) # la colonne 2
[1] 2 5 8 11
> print( maMat[,2,drop=FALSE] ) # la colonne 2 sans perdre la structure de matrice
[,1]
[1,] 2
[2,] 5
[3,] 8
[4,] 11
Pour sauvegarder des variables de session, on peut utiliser la fonction save(). On peut alors restaurer ces variables avec load(). Dans de nombreux environnements en mode interactif, toutes les variables courantes sont sauvegardées lorsqu'on quitte R.
Les listes et les data frame seront présentées dans la demi-journée 2.
4. Lectures de fichiers avec R
Comment fait-on pour lire des données dans un fichier ? Peut-on lire des fichiers sur Internet ?
On pourra utiliser les fichiers data01.txt, data02.txt, data03.txt, data04.csv et data05.xls pour tester les lectures, en local comme sur internet.
Questions spécialisées :
«Je travaille avec le logiciel mothur. Puis-je en lire les données avec R ?»
«Moi, j'utilise principalement des séquences Fasta trouvées sur Internet. Comment les lire avec R ? Exemple de données : le fichier cl8npnu.fasta».
«Moi, je ne m'intéresse qu'à la composition en AA de protéines stockées sur Uniprot dont je connais l'identifiant, comme par exemple Q75LD9».
«Je travaille surtout sur les titres d'articles de PubMed, comme celui-ci, référencé 11780146. Que peut R pour moi dans ce domaine ?
«Comment obtenir la séquence du gène X94991 ?»
Pour lire des données dans un fichier, on utilise la fonction read.table() et les fonctions associées comme read.csv() et read.xls(). A l'intérieur d'une session R, il suffit de taper help(read.table()) pour avoir la même aide que celle donnée par le lien [...]read.table.html.
Un fichier-texte peut avoir une première ligne spéciale qui contient les noms des colonnes. Il faut alors utiliser le paramètre header=TRUE. Si chaque ligne contient un identifiant de ligne (mot unique), on peut de plus utiliser le paramètre row.names.
Voici des exemples de telles lectures. On dispose du fichier suivant nommé data01.txt qui contient des distances en kilomètres et des gains en euros et dont le contenu est
200 300
300 150
250 200
450 250
La première ligne n'est pas spéciale et il n'y a pas d'identifiant de ligne. read.table("data01.txt") est donc suffisant.
Supposons maintenant que data02.txt contient une ligne 1 qui indique le nom des variables (distance et gain) et dont le contenu est
distance gain
200 300
300 150
250 200
450 250
Il faut donc utiliser read.table(file="data02.txt",header=TRUE).
Enfin, data03.txt contient en plus en début de chaque ligne après la première, un identifiant de ligne.
distance gain
Jour1 200 300
Jour2 300 150
Jour3 250 200
Jour4 450 250
On écrit alors read.table(file="data03.txt",header=TRUE,row.names=1).
Pour lire un fichier .csv comme data04.csv dont le contenu est
"","distance","gain"
"Jour1",200,300
"Jour2",300,150
"Jour3",250,200
"Jour4",450,250
on écrit read.csv("data04.csv").
Les fonctions read.table() et read.csv() font partie du package utils qui est chargé automatiquement avec R. Par contre pour read.xls() qui fait partie du package gdata et qui n'est pas chargé automatiquement avec R, il faut installer le package (une fois pour toutes) et charger (à chaque session) le package avec library() avant de pouvoir l'utiliser. On pourra le vérifier avec la lecture de data05.xls. On peut aussi utiliser le package XLConnect avec ses fonctions loadWorkbook() et readWorksheet() mais on ne peut lire que des fichiers locaux. Ce package XLConnect est utilisé par Rcmdr.
Il est d'usage d'affecter à une variable le résultat de la lecture, comme le montrent les instructions de l'extrait de session R suivant. Toutes ces fonctions R renvoient un data frame qui ressemble "un peu" à une matrice.
> read.table("data01.txt")
V1 V2
1 200 300
2 300 150
3 250 200
4 450 250
> read.table("data02.txt",header=TRUE)
distance gain
1 200 300
2 300 150
3 250 200
4 450 250
> read.table("data03.txt",header=TRUE,row.names=1)
distance gain
Jour1 200 300
Jour2 300 150
Jour3 250 200
Jour4 450 250
> mesdata <- read.csv("data04.csv")
> print( mesdata )
X distance gain
1 Jour1 200 300
2 Jour2 300 150
3 Jour3 250 200
4 Jour4 450 250
> mesdata2 <- read.xls("data05.xls")
Erreur : impossible de trouver la fonction "read.xls"
> library(gdata) # gdata a déjà été installé, on se contente de le charger
gdata: read.xls support for 'XLS' (Excel 97-2004) files ENABLED.
gdata: read.xls support for 'XLSX' (Excel 2007+) files ENABLED.
> mesdata2 <- read.xls("data05.xls")
> print( mesdata2 )
Jour distance gain
1 Jour1 200 300
2 Jour2 300 150
3 Jour3 250 200
4 Jour4 450 250
Si on veut exécuter les instructions des lignes d'un fichier comme essai.r il faut utiliser la fonction source() avec peut-être le paramètre encoding pour gérer les accents, soit le plus souvent encoding="latin1".
# ceci est mon premier fichier R (essai.r)
cat("Bonjour. ")
cat("Voici les données\n")
mesdata <- read.csv("data04.csv")
print(mesdata)
> source("essai.r")
Erreur dans source("essai.r") :
caractères multioctets incorrects dans l'analyse de code (parser) à la ligne 5
De plus : Message d'avis :
In grepl("\n", lines, fixed = TRUE) :
la chaîne de caractères entrée 5 est incorrecte dans cet environnement linguistique
> source("essai.r",encoding="latin1")
Bonjour. Voici les données
X distance gain
1 Jour1 200 300
2 Jour2 300 150
3 Jour3 250 200
4 Jour4 450 250
Réponses aux questions spécialisées :
Pour mothur il y a une fonction import_mothur dans le package nommé phyloseq.
Pour lire des séquences Fasta, il n'y a que l'embarras du choix. Voici par exemple comment faire avec la fonction readAAStringSet() du package Biostrings de Bioconductor puis avec la fonction read.fasta() du package seqinr avant d'utiliser la fonction read.fasta() du package muscle.
> library(Biostrings)
> cl8 <- readAAStringSet("cl8npnu.fasta",format="fasta")
> # pour vérification
> print( length(cl8) )
[1] 159
> print( head(cl8) )
A AAStringSet instance of length 6
width seq names
[1] 317 MSSSSENPTVTERGGGKDRRDDDGGEKKEGGGGFMEK...GKIDVDTPFGNMKLPISKEGGTTRIKKDDDDDDED AAS07355_1
[2] 345 MREGWRKYKLLSSLSSSPQLHFLTRAMASDDKPEVAE...TPFGVMKLPISKEGGTTRLKKKKDDGSYDDDDDED AAV71142_1
[3] 304 TPLFEFRVSSSSFLAALCSTVLTFLFYTLRYLLGMAS...LTKSIKIEKNGITLMGDSNHFSGLRTLGSALWGYD AAX19869_1
[4] 327 MSSSEEMEKQKEKEETSVIERGLKKDKKDEDEDEEKG...DSPFGPMQLPFNKEGGSTRLKKKNKEEGDEDDDED ABK25013_1
[5] 315 MASSDKPEIVDRDVKEDDKDEEKGGFIDKVKDFIQDI...TPFGAMKLPISKEGGTTRLKKSKEDGGDDDDDDEE ABK95225_1
[6] 321 MSSSENPEIVERVFGDKEKEEKEDKKDEQKGGFIEKV...DTPFGAMKLPISKGGGTTRLKKNKEDGGDDDEDED ABS50432_1
####################################################################################################
> library(seqinr)
> # on notera qu'on ouvre le fichier sur Internet
> url <- "http://forge.info.univ-angers.fr/~gh/wstat/Introduction_R/cl8npnu.fasta"
> cl8 <- read.fasta(url,seqtype="AA")
> # pour vérification
> print( length(cl8) )
[1] 159
> print( head(cl8,n=2) )
$AAS07355_1
[1] "M" "S" "S" "S" "S" "E" "N" "P" "T" "V" "T" "E" "R" "G" "G" "G" "K" "D" "R" "R" "D" "D" "D" "G" "G"
[26] "E" "K" "K" "E" "G" "G" "G" "G" "F" "M" "E" "K" "V" "K" "D" "F" "I" "H" "D" "I" "G" "E" "K" "I" "E"
[51] "G" "A" "V" "G" "F" "G" "K" "P" "T" "A" "D" "V" "S" "G" "V" "H" "I" "P" "H" "I" "S" "L" "H" "R" "A"
[76] "D" "L" "V" "V" "D" "V" "L" "I" "K" "N" "P" "N" "P" "V" "P" "I" "P" "L" "V" "D" "I" "D" "Y" "L" "I"
[101] "E" "S" "D" "G" "R" "K" "L" "V" "S" "G" "L" "I" "P" "D" "A" "G" "T" "I" "H" "A" "H" "G" "E" "E" "T"
[126] "V" "K" "I" "P" "I" "S" "L" "I" "Y" "D" "D" "I" "K" "S" "T" "Y" "N" "D" "I" "K" "P" "G" "S" "I" "I"
[151] "P" "Y" "L" "V" "R" "V" "V" "L" "L" "I" "D" "V" "P" "I" "I" "G" "R" "I" "K" "L" "P" "L" "E" "K" "S"
[176] "G" "E" "I" "P" "I" "P" "Y" "K" "P" "D" "V" "D" "V" "E" "K" "I" "K" "F" "H" "R" "F" "S" "F" "E" "E"
[201] "T" "T" "A" "T" "L" "H" "L" "K" "L" "E" "N" "K" "N" "D" "F" "D" "L" "G" "L" "N" "M" "L" "E" "Y" "E"
[226] "M" "W" "L" "G" "D" "D" "S" "V" "A" "S" "A" "E" "L" "T" "E" "S" "A" "T" "I" "E" "K" "Q" "G" "I" "T"
[251] "T" "M" "Q" "V" "P" "F" "S" "F" "R" "P" "K" "D" "F" "G" "S" "A" "V" "W" "D" "M" "I" "R" "G" "R" "G"
[276] "T" "G" "Y" "T" "I" "K" "G" "K" "I" "D" "V" "D" "T" "P" "F" "G" "N" "M" "K" "L" "P" "I" "S" "K" "E"
[301] "G" "G" "T" "T" "R" "I" "K" "K" "D" "D" "D" "D" "D" "D" "E" "D" " "
attr(,"name")
[1] "AAS07355_1"
attr(,"Annot")
[1] ">AAS07355_1"
attr(,"class")
[1] "SeqFastaAA"
$AAV71142_1
[1] "M" "R" "E" "G" "W" "R" "K" "Y" "K" "L" "L" "S" "S" "L" "S" "S" "S" "P" "Q" "L" "H" "F" "L" "T" "R"
[26] "A" "M" "A" "S" "D" "D" "K" "P" "E" "V" "A" "E" "R" "V" "T" "R" "G" "K" "D" "H" "E" "E" "E" "K" "E"
[51] "E" "D" "K" "G" "G" "F" "I" "D" "K" "V" "K" "D" "F" "I" "Q" "D" "I" "G" "E" "K" "I" "E" "G" "A" "I"
[76] "G" "F" "G" "K" "P" "T" "A" "D" "V" "S" "G" "V" "H" "F" "P" "H" "I" "D" "L" "H" "K" "A" "E" "V" "I"
[101] "V" "D" "V" "L" "V" "K" "N" "P" "N" "P" "V" "L" "I" "P" "L" "I" "D" "I" "N" "Y" "L" "I" "E" "S" "D"
[126] "G" "R" "K" "L" "V" "S" "G" "L" "I" "R" "D" "A" "G" "T" "I" "R" "A" "H" "G" "S" "E" "T" "V" "K" "I"
[151] "P" "V" "N" "V" "I" "Y" "D" "Y" "I" "K" "S" "T" "Y" "E" "D" "I" "K" "P" "G" "S" "I" "I" "P" "Y" "N"
[176] "V" "K" "V" "D" "L" "I" "I" "D" "V" "P" "V" "I" "G" "R" "I" "T" "I" "P" "L" "Q" "K" "T" "G" "E" "I"
[201] "P" "V" "P" "Y" "K" "P" "D" "I" "D" "V" "E" "K" "I" "H" "F" "E" "R" "F" "S" "F" "E" "E" "T" "I" "A"
[226] "T" "L" "K" "L" "K" "L" "E" "N" "K" "N" "D" "F" "D" "L" "G" "L" "N" "A" "L" "D" "Y" "E" "V" "W" "L"
[251] "G" "D" "E" "N" "I" "G" "G" "A" "E" "L" "Q" "K" "S" "A" "K" "I" "E" "K" "N" "G" "I" "T" "H" "M" "D"
[276] "L" "P" "I" "S" "F" "R" "P" "K" "D" "F" "G" "S" "A" "L" "W" "D" "M" "I" "R" "G" "S" "G" "T" "G" "Y"
[301] "T" "M" "K" "G" "N" "I" "D" "V" "D" "T" "P" "F" "G" "V" "M" "K" "L" "P" "I" "S" "K" "E" "G" "G" "T"
[326] "T" "R" "L" "K" "K" "K" "K" "D" "D" "G" "S" "Y" "D" "D" "D" "D" "D" "E" "D" " "
attr(,"name")
[1] "AAV71142_1"
attr(,"Annot")
[1] ">AAV71142_1"
attr(,"class")
[1] "SeqFastaAA"
####################################################################################################
> library(protr)
> ids <- c("Q75LD9","A9NWK2")
> cl8p <- getUniProt( ids )
> # pour vérification
> print( length(cl8p) )
[1] 2
> print( head(cl8p) )
[[1]]
[1] "MSSSSENPTVTERGGGKDRRDDDGG...
[[2]]
[1] "MSSSEEMEKQKEKEETSVIERGLKKDKK...
####################################################################################################
> detach(package:seqinr)
> library(muscle)
> cl8 <- read.fasta("cl8npnu.fasta")
> # pour vérification
> print( length(cl8) )
[1] 2
> print( head(cl8) )
####################################### affichage réorganisé pour la page WEB
$seqs
V1 V2
1 AAS07355_1 MSSSSENPTVTERGG...
2 AAV71142_1 MREGWRKYKLLSSLS....
3 AAX19869_1 TPLFEFRVSSSSFLA...
...
$num
[1] 159
Pour obtenir les séquences Fasta de protéines (ou leur composition en AA) dont on connait l'identifiant Uniprot, là aussi, il n'y a que l'embarras du choix. Voici par exemple comment faire avec la fonction getUniProt() du package protr puis avec la fonction util.fasta() du package CHNOSZ. Il y aussi une fonction read.fasta() dans ce package.
> library(protr)
> ids <- c("Q75LD9","A9NWK2")
> cl8p <- getUniProt( ids )
> # pour vérification
> print( length(cl8p) )
[1] 2
> print( head(cl8p) )
[[1]]
[1] "MSSSSENPTVTERGGGKDRRDDDGG...
[[2]]
[1] "MSSSEEMEKQKEKEETSVIERGLKKDKK...
####################################################################################################
> library(CHNOSZ)
> myp <- uniprot.aa( "Q75LD9" )
uniprot.aa: trying http://www.uniprot.org/uniprot/Q75LD9 ... accession Q75LD9 ...
uniprot.aa: NA from NA (length 316)
> # pour vérification
> print( length(myp) )
[1] 25
> print( head(myp) )
protein organism ref abbrv chains Ala Cys Asp Glu Phe Gly His Ile Lys Leu Met Asn Pro Gln Arg Ser Thr
1 Q75LD9 <NA> NA NA 1 10 0 34 23 11 32 8 32 27 22 7 8 20 2 12 19 18
Val Trp Tyr
1 22 2 7
> #####################################################
>
> library(CHNOSZ)
> cl8 <- read.fasta("cl8npnu.fasta")
read.fasta: reading cl8npnu.fasta
> # pour vérification
> print( length(cl8) )
[1] 25
> print( head(cl8) )
> print( head(cl8) )
protein organism ref abbrv chains Ala Cys Asp Glu Phe Gly His Ile Lys Leu Met Asn Pro Gln Arg Ser Thr Val Trp Tyr
1 AAS07355 cl8npnu NA NA 1 10 0 34 23 11 32 8 32 27 22 7 8 20 2 12 19 18 22 2 7
2 AAV71142 cl8npnu NA NA 1 13 0 36 26 12 30 8 35 34 26 6 11 19 4 13 19 16 23 3 10
3 AAX19869 cl8npnu NA NA 1 15 1 21 27 14 20 6 33 27 31 2 11 17 1 6 21 18 21 2 9
4 ABK25013 cl8npnu NA NA 1 12 0 32 32 12 27 4 31 38 25 7 13 20 4 5 22 11 21 2 8
5 ABK95225 cl8npnu NA NA 1 11 0 37 26 13 27 5 37 32 22 4 12 20 1 8 14 15 20 2 8
6 ABS50432 cl8npnu NA NA 1 10 0 32 28 12 27 6 34 33 25 4 16 20 3 9 14 15 22 2 8
Via Bioconductor il est possible de consulter et d'interroger facilement PubMed, notamment avec le package annotate et sa fonction pubmed. Voici un exemple d'utilisation :
# chargement de la biblothèque
library(annotate)
# visualisation de l'abstract dans l'environnement
pubmed("11780146",disp="data")
# visualisation de plusieurs abstracts avec Firefox
pubmed("11780146","11886385","11884611",disp="browser")
$doc
$file
[1] "<buffer>"
$version
[1] "1.0"
$children
$children$PubmedArticleSet
<PubmedArticleSet>
<PubmedArticle>
<MedlineCitation Owner="NLM" Status="MEDLINE">
<PMID Version="1">11780146</PMID>
<DateCreated>
<Year>2002</Year>
<Month>01</Month>
<Day>28</Day>
</DateCreated>
<DateCompleted>
<Year>2002</Year>
<Month>02</Month>
<Day>21</Day>
</DateCompleted>
<DateRevised>
<Year>2006</Year>
<Month>11</Month>
<Day>15</Day>
</DateRevised>
<Article PubModel="Print">
<Journal>
<ISSN IssnType="Print">1072-8368</ISSN>
<JournalIssue CitedMedium="Print">
<Volume>9</Volume>
<Issue>2</Issue>
<PubDate>
<Year>2002</Year>
<Month>Feb</Month>
</PubDate>
</JournalIssue>
<Title>Nature structural biology</Title>
<ISOAbbreviation>Nat. Struct. Biol.</ISOAbbreviation>
</Journal>
<ArticleTitle>Structure of the Bcr-Abl oncoprotein oligomerization domain.</ArticleTitle>
<Pagination>
<MedlinePgn>117-20</MedlinePgn>
</Pagination>
<Abstract>
<AbstractText>The Bcr-Abl oncoprotein is responsible for a wide range of human leukemias,
including most cases of Philadelphia chromosome-positive chronic myelogenous leukemia.
Oligomerization of Bcr-Abl is essential for oncogenicity. We determined the crystal
structure of the N-terminal oligomerization domain of Bcr-Abl (residues 1-72 or Bcr1-72)
and found a novel mode of oligomer formation. Two N-shaped monomers dimerize by swapping
N-terminal helices and by forming an antiparallel coiled coil between C-terminal helices.
Two dimers then stack onto each other to form a tetramer. The Bcr1-72 structure provides
a basis for the design of inhibitors of Bcr-Abl transforming activity by disrupting Bcr-Abl
oligomerization.
</AbstractText>
</Abstract>
<Affiliation>Howard Hughes Medical Institute, Whitehead Institute for Biomedical Research, Department
of Biology, Massachusetts Institute of Technology, Nine Cambridge Center, Cambridge,
Massachusetts 02142-1401, USA.</Affiliation>
[...]
La page ouverte en automatique par le navigateur est [...]pubmed/11780146%2C[...].
Pour rapatrier la séquence du gène X94991, le plus simple est sans doute d'utiliser la fonction read.GenBank du package ape (avec un jeu de mots sur l'acronyme du package qui est mis pour Analyses of Phylogenetics and Evolution) :
# chargement de la librairie
library(ape)
# lecture du gène demandé
geneX <- read.GenBank("X94991.1",as.character=TRUE)
# comptage par type de nucléotide
table(geneX)
# un chi-deux rapide
print(chisq.test(table(geneX)))
# un chi-deux détaillé en français avec conclusion
chi2Adeq(rep(length(geneX[[1]])/4,4),table(geneX))
# au passage, comment était stockée la séquence du gène ?
print( ls.str(geneX) )
geneX
a c g t
410 789 573 394
Chi-squared test for given probabilities
data: table(geneX)
X-squared = 187.0674, df = 3, p-value < 2.2e-16
CALCUL DU CHI-DEUX D'ADEQUATION
Valeurs théoriques 541.5 541.5 541.5 541.5
Valeurs observées 410 789 573 394
Valeur du chi-deux 187.0674
Chi-deux max (table) à 5 % 7.814728 pour 3 degrés de liberté ; p-value 2.62465e-40
décision : au seuil de 5 % on peut rejeter l'hypothèse
que les données observées correspondent aux valeurs théoriques.
X94991.1 : chr [1:2166] "c" "g" "g" "c" "c" "c" "g" "g" "c" "c" "a" "t" "g" "g" "c" "g" "g" "c" "c" "c" "c" "c" "c" "g" "c" "c" "c" "g" ...
Remarque : X94991 est décrit au NCBI par GI:1155087 et semble donc être relié à la zyxine.
5. Calculs simples et manipulations élémentaires en R
Comment créer des variables, les lister, les supprimer ? Comment convertir des données, par exemple de pouces en cm ? Comment recoder, par exemple avec la valeur 0 pour moins de 10 et 1 sinon ? Et pour trier des données ?
Pour créer une variable, il suffit de lui affecter une valeur. Ainsi x <- 3 crée la variable x et lui affecte la valeur 3. Si x existait déjà, son ancien contenu est perdu et remplacé par 3. R n'est pas vraiment typé explicitement dans la mesure où x peut changer de type, par exemple passer de nombre à chaine de caractères, sans que cela ne pose de problème.
Pour supprimer la variable x, on utilise la fonction rm(). On exécute donc rm(x). rm signifie remove. Pour connaitre la liste de toutes les variables, on peut taper ls() ou ls.str(). La fonction ls() liste les variables, d'où son abbréviation en ls alors que ls.str() essaie d'afficher les valeurs en chaine (string en anglais). Il faut donc être très prudent(e) avec rm(list=ls()) car cela supprime toutes les variables courantes. Rstudio fournit et maintient la liste des variables courantes dans une fenêtre séparée.
Pour effectuer un calcul en R, il faut utiliser la syntaxe des informaticiens : * pour la multiplication, / pour la division, ** pour la puissance, mettre des parenthèses pour les noms de fonctions comme log(), sinus()... Comme R est vectoriel, de nombreux calculs sont automatiquement réalisés sur chacun des éléments des vecteurs ou de la matrice. Par exemple :
> # quelques calculs simples
>
> ( x <- 3 )
[1] 3
> ( y <- 2 )
[1] 2
> ( c1 <- x+y )
[1] 5
> ( c2 <- x*y )
[1] 6
> ( c3 <- x/y )
[1] 1.5
> ( c4 <- x %% y )
[1] 1
> print( c( log(10), exp(1), log(x=10, base=2) ) )
[1] 2.302585 2.718282 3.321928
> print( dbinom(x=3,size=7,prob=0.1) ) # mais est-ce vraiment simple ?
[1] 0.0229635
> # fonctions pour vecteur
>
> vec <- c(5,10,1)
> print(length(vec)) # sa longueur = nombre d'éléments
[1] 3
> print(sum(vec)) # la somme de ses éléments
[1] 16
> # calculs vectoriels
>
> ( v1 <- 1:10 )
[1] 1 2 3 4 5 6 7 8 9 10
> ( v2 <- v1**3 )
[1] 1 8 27 64 125 216 343 512 729 1000
> ( v3 <- v1 + 0.3 )
[1] 1.3 2.3 3.3 4.3 5.3 6.3 7.3 8.3 9.3 10.3
> ( v4 <- v1 + v2 )
[1] 2 10 30 68 130 222 350 520 738 1010
> ( maMat <- matrix(1:6, nrow=4, ncol=3, byrow=TRUE) )
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 1 2 3
[4,] 4 5 6
> ( v5 <- maMat[1,] + maMat[2,] )
[1] 5 7 9
Pour ajouter des valeurs à un vecteur, on peut utiliser la fonction c(). Pour ajouter des valeurs à une matrice, on utilise les fonctions cbind() et rbind() mais il vaut mieux passer par transform() pour compléter un data frame. Via la fonction ifelse() on peut réaliser des recodages simples. Voici un exemple de telles manipulations.
> # ajouts et suppressions
>
> ( maMat <- matrix(1:6, nrow=4, ncol=3, byrow=TRUE) )
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 1 2 3
[4,] 4 5 6
> # ceci échoue : ( maMat[5,] <- maMat[1,] + maMat[2,] )
> # car on n'a que 4 lignes
>
> ( rbind(maMat, maMat[1,] + maMat[2,] ) ) # là, tout va bien
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 1 2 3
[4,] 4 5 6
[5,] 5 7 9
> # mais maMat n'a pas changé
>
> print(maMat)
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 1 2 3
[4,] 4 5 6
> maMat <- rbind(maMat, maMat[1,] + maMat[2,] ) # là, elle change
> print(maMat)
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 1 2 3
[4,] 4 5 6
[5,] 5 7 9
> # transformations
>
> ( maMat <- transform( maMat, cm=maMat[,1]*2.54) )
X1 X2 X3 cm
1 1 2 3 2.54
2 4 5 6 10.16
3 1 2 3 2.54
4 4 5 6 10.16
5 5 7 9 12.70
> ( maMat <- transform( maMat, binaire=ifelse(cm<10,0,1) ) )
X1 X2 X3 cm binaire
1 1 2 3 2.54 0
2 4 5 6 10.16 1
3 1 2 3 2.54 0
4 4 5 6 10.16 1
5 5 7 9 12.70 1
On peut trier explicitement des données avec la fonction sort() mais pour trier dans des structures, on a souvent recours à la fonction order() :
> # tris et indexations en R
>
> ( v <- c(12,18,5,11,50,6) )
[1] 12 18 5 11 50 6
> ( order(v) )
[1] 3 6 4 1 2 5
> ( sort(v) )
[1] 5 6 11 12 18 50
> ( v[ order(v) ] )
[1] 5 6 11 12 18 50
> ( v[ rev(order(v)) ] )
[1] 50 18 12 11 6 5
> ( v[ order(v,decreasing=TRUE) ] )
[1] 50 18 12 11 6 5
> # pour une matrice
>
> uneMat <- matrix(nrow=4,ncol=3,
+ data=c( 1,10,4,8, v, 7, 0 )
+ ) # fin de matrix
> ( uneMat )
[,1] [,2] [,3]
[1,] 1 12 50
[2,] 10 18 6
[3,] 4 5 7
[4,] 8 11 0
> # surtout pas !
>
> ( sort(uneMat) )
[1] 0 1 4 5 6 7 8 10 11 12 18 50
> # tri suivant une colonne
>
> idxC <- order( uneMat[,1] )
> print( uneMat[ idxC, ] )
[,1] [,2] [,3]
[1,] 1 12 50
[2,] 4 5 7
[3,] 8 11 0
[4,] 10 18 6
> # tri suivant une ligne
>
> idxL <- order( uneMat[2,] )
> print( uneMat[ ,idxL ] )
[,1] [,2] [,3]
[1,] 50 1 12
[2,] 6 10 18
[3,] 7 4 5
[4,] 0 8 11
6. Documentation et système d'aide
Comment apprendre à utiliser le logiciel R ?
Où et comment obtenir de l'aide et de la documentation pour le logiciel R ?
Le site officiel de R a une rubrique manuals avec des manuels en anglais. Heureusement, ces documents sont traduits dans plusieurs langues et chaque pays contribue à la documentation générale dans la section Contributed Documentation.
De plus, il y a aujourd'hui (2013) de nombreux ouvrages généraux et aussi spécialisés sur R, notamment chez Springer avec les séries Use R! et Pratique R. Voir par exemple nos pages livres sur R et ouvrages pour R.
A l'intérieur de R, en mode interactif, on utilise la fonction help(f) pour avoir de l'aide sur la fonction f et example(f) pour voir des exemples d'utilisation. Ainsi help(median) montre les paramètres de la fonction median() tandis que example(lm) montre la fonction lm() en action. L'aide par défaut s'affiche dans une fenêtre surgissante, mais si on tape help.start() tout appel de l'aide s'affiche dans le navigateur.
On trouve aussi des vidéos sur YouTube notamment qui montrent comment utiliser le logiciel R. Il faut chercher R software et non pas seulement R.
Des sites comme R Site Search et R seek sont également utiles. Nous conseillons à la solution de la question S1q13 d'autres sites français et anglais dont le site français duclert.
Comme R est très complet et très riche en fonctions, on apprend en général R au fur et à mesure de ses besoins. Comme chaque package a ses propres fonctions, il n'est pas possible de connaitre R entièrement. On estime généralement qu'en connaissant une petite centaine de fonctions générales, on arrive à réaliser la plupart des opérations courantes en R.
Dans une session R, en plus de help() et ? (un point d'interrogation), on peut aussi utiliser apropos() et ?? (deux points d'interrogation).
7. Fonctions et packages, bioconductor
Qu'est-ce qu'un package en R ? Comment s'y retrouver ? Comment installer, charger, dé-charger un package ? Quels sont les principaux packages ? Comment installer un package dans environnement contraint, par exemple si on'a pas le droit, comme à la fac, d'écrire dans le répertoire de R ? Qu'est-ce que Bioconductor ?
Un package est un ensemble de fonctions, de données, de textes d'aide et d'exemples d'utilisation. Compte-tenu du grand nombre (plusieurs milliers) de packages, il faut en général passer par les task views du CRAN ou utiliser un système de recherche comme R Site Search pour trouver ce qu'on cherche. Il est également possible de chercher "à l'aveuglette" un mot particulier dans la liste longue des packages.
On installe un package à l'aide la fonction install.packages() et on le charge par library(). Il n'est pas obligatoire (sauf en cas de conflit avec d'autres packages) de l'enlever de la mémoire, car R ne garde pas trace des packages chargés d'une session à l'autre. Si on doit vraiment le dé-charger de la mémoire, on utilise detach(). Dans un environnement contraint, il faut utiliser le paramètre lib pour spécifier un emplacement local accessible en écriture. Voir par exemple notre note locale sur R.
Pour connaitre la liste des jeux de données fournis avec un package, il faut utiliser la fonction data() alors que la liste de tous les objets du package est obtenue via ls(). Signalons que help(package="nom_package") fournit la page index de l'aide et que vignette("nom_package") affiche le PDF associé lorsqu'il existe.
Voici un exemple d'utilisation de ces fonctions :
> # chargement du package seqinr
>
> library(seqinr)
> # lecture de la page principale d'aide (aménagé)
>
> help(seqinr)
seqinr-package package:seqinr R Documentation
Biological Sequences Retrieval and Analysis
Description:
Exploratory data analysis and data visualization for biological
sequence (DNA and protein) data. Include also utilities for
sequence data management under the ACNUC system.
Author(s):
Delphine Charif and Jean R. Lobry and Anamaria Necsulea and Leonor
Palmeira
Maintainer: Simon Penel <penel@biomserv.univ-lyon1.fr>
References:
citation('seqinr')
> # liste des objets du package (début)
>
> head( ls("package:seqinr") )
[1] "a" "aaa" "aacost" "aaindex" "AAstat" "acnucclose"
> # liste des données du package (aménagé)
>
> ( data(package="seqinr") )
Data sets in package seqinr:
AnoukResult Expected numeric results for Ka and Ks computation
ECH Forensic Genetic Profile Allelic Ladder Raw Data
EXP Vectors of coefficients to compute linear forms.
JLO Forensic Genetic Profile Raw Data
SEQINR.UTIL utility data for seqinr
aacost Aerobic cost of amino-acids in Escherichia coli and G+C classes
aaindex List of 544 physicochemical and biological properties for the 20 amino-acids
caitab Codon Adaptation Index (CAI) w tables
chargaff Base composition in ssDNA for 7 bacterial DNA
clustal Example of results obtained after a call to read.alignment
dinucl Mean zscore on 242 complete bacterial chromosomes
ec999 999 coding sequences from E. coli
fasta Example of results obtained after a call to read.alignment
gs500liz GS500LIZ size standards
identifiler Identifiler allele names
m16j Fragment of the E. coli chromosome
mase Example of results obtained after a call to read.alignment
msf Example of results obtained after a call to read.alignment
pK pK values for the side chain of charged amino acids from various sources
phylip Example of results obtained after a call to read.alignment
prochlo Zscore on three strains of Prochlorococcus marinus
revaligntest Three aligned nucleic acid sequences
toyaa A toy example of amino-acid counts in three proteins
toycodon A toy example of codon counts in three coding sequences
waterabs Light absorption by the water column
> # désignation longue (mais head(aaindex,n=10) était suffisant)
>
> ( head(seqinr::aaindex,n=10) )
$ANDN920101
$ANDN920101$H
[1] "ANDN920101"
$ANDN920101$D
[1] "alpha-CH chemical shifts (Andersen et al., 1992)"
$ANDN920101$R
[1] "LIT:1810048b PMID:1575719"
$ANDN920101$A
[1] "Andersen, N.H., Cao, B. and Chen, C."
$ANDN920101$T
[1] "Peptide/protein structure analysis using the chemical shift index method:
upfield alpha-CH values reveal dynamic helices and aL sites"
$ANDN920101$J
[1] "Biochem. and Biophys. Res. Comm. 184, 1008-1014 (1992)"
$ANDN920101$C
[1] "BUNA790102 0.949"
$ANDN920101$I
Ala Arg Asn Asp Cys Gln Glu Gly His Ile Leu Lys Met Phe Pro Ser Thr Trp Tyr Val
4.35 4.38 4.75 4.76 4.65 4.37 4.29 3.97 4.63 3.95 4.17 4.36 4.52 4.66 4.44 4.50 4.35 4.70 4.60 3.95
$ARGP820101
$ARGP820101$H
[1] "ARGP820101"
$ARGP820101$D
[1] "Hydrophobicity index (Argos et al., 1982)"
$ARGP820101$R
[1] "LIT:0901079b PMID:7151796"
$ARGP820101$A
[1] "Argos, P., Rao, J.K.M. and Hargrave, P.A."
$ARGP820101$T
[1] "Structural prediction of membrane-bound proteins"
$ARGP820101$J
[1] "Eur. J. Biochem. 128, 565-575 (1982)"
$ARGP820101$C
[1] "JOND750101 1.000 SIMZ760101 0.967 GOLD730101 0.936TAKK010101 0.906
MEEJ810101 0.891 ROSM880104 0.872CIDH920105 0.867 LEVM760106 0.865
CIDH920102 0.862MEEJ800102 0.855 MEEJ810102 0.853 ZHOH040101 0.841
CIDH920103 0.827 PLIV810101 0.820 CIDH920104 0.819LEVM760107 0.806
NOZY710101 0.800 GUYH850103 -0.808PARJ860101 -0.835 WOLS870101 -0.838
BULH740101 -0.854"
$ARGP820101$I
Ala Arg Asn Asp Cys Gln Glu Gly His Ile Leu Lys Met Phe Pro Ser Thr Trp Tyr Val
0.61 0.60 0.06 0.46 1.07 0.00 0.47 0.07 0.61 2.22 1.53 1.15 1.18 2.02 1.95 0.05 0.05 2.65 1.88 1.32
$ARGP820102
$ARGP820102$H
[1] "ARGP820102"
$ARGP820102$D
[1] "Signal sequence helical potential (Argos et al., 1982)"
$ARGP820102$R
[1] "LIT:0901079b PMID:7151796"
$ARGP820102$A
[1] "Argos, P., Rao, J.K.M. and Hargrave, P.A."
$ARGP820102$T
[1] "Structural prediction of membrane-bound proteins"
$ARGP820102$J
[1] "Eur. J. Biochem. 128, 565-575 (1982)"
$ARGP820102$C
[1] "ARGP820103 0.961 KYTJ820101 0.803 JURD980101 0.802"
$ARGP820102$I
Ala Arg Asn Asp Cys Gln Glu Gly His Ile Leu Lys Met Phe Pro Ser Thr Trp Tyr Val
1.18 0.20 0.23 0.05 1.89 0.72 0.11 0.49 0.31 1.45 3.23 0.06 2.67 1.96 0.76 0.97 0.84 0.77 0.39 1.08
$ARGP820103
$ARGP820103$H
[1] "ARGP820103"
$ARGP820103$D
[1] "Membrane-buried preference parameters (Argos et al., 1982)"
$ARGP820103$R
[1] "LIT:0901079b PMID:7151796"
$ARGP820103$A
[1] "Argos, P., Rao, J.K.M. and Hargrave, P.A."
$ARGP820103$T
[1] "Structural prediction of membrane-bound proteins"
$ARGP820103$J
[1] "Eur. J. Biochem. 128, 565-575 (1982)"
$ARGP820103$C
[1] "ARGP820102 0.961 MIYS850101 0.822 NAKH900106 0.810EISD860103 0.810
KYTJ820101 0.806 JURD980101 0.800PUNT030101 -0.810 MIYS990102 -0.814
MIYS990101 -0.817"
$ARGP820103$I
Ala Arg Asn Asp Cys Gln Glu Gly His Ile Leu Lys Met Phe Pro Ser Thr Trp Tyr Val
1.56 0.45 0.27 0.14 1.23 0.51 0.23 0.62 0.29 1.67 2.93 0.15 2.96 2.03 0.76 0.81 0.91 1.08 0.68 1.14
$BEGF750101
$BEGF750101$H
[1] "BEGF750101"
$BEGF750101$D
[1] "Conformational parameter of inner helix (Beghin-Dirkx, 1975)"
$BEGF750101$R
[1] "LIT:1309065 PMID:50789"
$BEGF750101$A
[1] "Beghin, F. and Dirkx, J."
$BEGF750101$T
[1] "Une methode statistique simple de prediction des conformations proteiques"
$BEGF750101$J
[1] "Arch. Int. Physiol. Biochim. 83, 167-168 (1975)"
$BEGF750101$C
[1] "KANM800103 0.893 AURR980113 0.857 ROBB760103 0.852CHOP780201 0.841
QIAN880105 0.833 AURR980109 0.821QIAN880107 0.815 PALJ810102 0.811
AURR980108 0.810CHOP780101 -0.803 CHOP780210 -0.804 CRAJ730103 -0.812
ROBB760108 -0.819 ROBB760113 -0.826 CHAM830101 -0.854PALJ810106 -0.859"
$BEGF750101$I
Ala Arg Asn Asp Cys Gln Glu Gly His Ile Leu Lys Met Phe Pro Ser Thr Trp Tyr Val
1.00 0.52 0.35 0.44 0.06 0.44 0.73 0.35 0.60 0.73 1.00 0.60 1.00 0.60 0.06 0.35 0.44 0.73 0.44 0.82
$BEGF750102
$BEGF750102$H
[1] "BEGF750102"
$BEGF750102$D
[1] "Conformational parameter of beta-structure (Beghin-Dirkx, 1975)"
$BEGF750102$R
[1] "LIT:1309065 PMID:50789"
$BEGF750102$A
[1] "Beghin, F. and Dirkx, J."
$BEGF750102$T
[1] "Une methode statistique simple de prediction des conformations proteiques"
$BEGF750102$J
[1] "Arch. Int. Physiol. Biochim. 83, 167-168 (1975)"
$BEGF750102$C
[1] "CORJ870105 0.878 CORJ870106 0.853 PRAM900103 0.834LEVM780102 0.834
PALJ810110 0.834 NAGK730102 0.833CORJ870107 0.831 QIAN880120 0.829
QIAN880119 0.811ROBB760106 0.809 PTIO830102 0.807 LIFS790101 0.807
MIYS850101 0.806 PONP800107 0.803 PALJ810104 0.801CORJ870108 -0.825
MEIH800101 -0.832 RACS770101 -0.840"
$BEGF750102$I
Ala Arg Asn Asp Cys Gln Glu Gly His Ile Leu Lys Met Phe Pro Ser Thr Trp Tyr Val
0.77 0.72 0.55 0.65 0.65 0.72 0.55 0.65 0.83 0.98 0.83 0.55 0.98 0.98 0.55 0.55 0.83 0.77 0.83 0.98
[... lignes omises]
>vignette("affy") # n'affiche rien dans R, mais acrobat est lancé
# et on peut visualiser affy.pdf
Au risque de choquer ou de surprendre, il n'y a pas de package principal ou plus important qu'un autre. Il y a des packages essentiels, chargés dès l'invocation de R, comme base, stats, graphics, grDevices, utils, datasets et methods, mais aucun package n'est plus important qu'un autre. Tout dépend de ce que l'on doit réaliser comme tâche.
Bioconductor, dont l'adresse est http://www.bioconductor.org/ est un site qui fournit des library R orientées analyse bioinformatique, puces à ADN et autres technologies NGS. On y trouve par exemple les bibliothèques telle que Affy ou Biobase qui étaient très utilisées dans l'analyse statistique de ces puces à ADN dans les années 2000. Aujourd'hui (2014), on y trouve des librairies pour miseq, RNA-Seq, illumina...
Bioconductor fonctionne séparément du CRAN et a son propre système d'installation de packages. En mars 2014, Bioconductor comptait plus de 1600 packages, répartis en environ 750 packages de programmes, 700 packages de données d'annotations et 180 packages de données expérimentales. Pour utiliser Bioconductor, il faut écrire :
source("http://bioconductor.org/biocLite.R")
biocLite()
Ceci installe les packages élémentaires de Bioconductor, dont Biobase.
Pour installer un package, par exemple illuminaio avec Bioconductor, il faut écrire
biocLite("illuminaio")
Comme tout package R, les packages R de Bioconductor ont leur fichier PDF d'aide (ou "vignette"), mais pas toujours de jeux de données, car ceux-ci sont souvent gros et téléchargeables via des packages spécialisés. Compte-tenu de l'évolution rapide des technologies et des méthodes associées, il y a aussi souvent en plus un tutoriel sur l'utilisation du package.
Il est clair que le nombre important de packages dans Bioconductor rend impossible la maitrise de l'ensemble des packages. C'est pourquoi on trouve peu d'ouvrages comme ceux présentés ci-dessous mais plutôt des articles citant ou utilisant ces packages.
Pour une introduction rapide à Bioconductor et des exemples d'analyses avec Bioconductor, on pourra notamment lire en anglais Bioconductor-tutorial.pdf et, en français, TP_Affy.pdf disponibles ici et là en version locale. Pour une introduction aux statistiques simples et avancées en bioinformatique, nous vous conseillons au passage soit le document Krijnen du CRAN (copie locale) soit le document little-rbio (copie locale).
8. Avantages et inconvénients de R
Quels sont les avantages (les points forts) de R ?
Et ses inconvénients (ses points faibles) ?
Les plus grands points forts de R sont sa gratuité et le fait qu'il soit très complet. Les autres grands logiciels statistiques comme SAS ou Statistica sont payants et encore : on ne les achète pas, on les loue pour quelques centaines d'euros par an et par ordinateur, soit au final un coût très élevé. De plus ils ne couvrent pas tous les domaines scientifiques récents où on a besoin des statistiques, notamment la bioinformatique.
Un autre point fort de R est sa modularité. On apprend au fur et à mesure car la plupart des packages sont indépendants.
La facilité d'utilisation est à la fois un avantage et un inconvénient. Il est instantané d'utiliser la fonction mean() et la fonction median() pour calculer respectivement la moyenne et la médiane d'une série de valeurs, mais comment savoir laquelle il faut vraiment utiliser ? De la même façon, toute méthode complexe ou simplement récente est disponible mais comme pour un menu dans un logiciel, il n'y a pas de recul conceptuel fourni, juste une ressource disponible, sauf à s'astreindre à lire l'aide.
La grande richesse des packages est aussi à la fois un avantage et un inconvénient. Nous avons vu par exemple précédemment au moins trois façons de lire des séquences Fasta avec des packages différents. Devant la multitude, il est souvent difficile de choisir.
> ?? DNA
Vignettes with name or keyword or title matching DNA using regular expression matching:
Biostrings::Biostrings2Classes A short presentation of the basic classes defined in Biostrings 2
Biostrings::BiostringsQuickOverview Biostrings Quick Overview
Biostrings::MultipleAlignments Multiple Alignments
Biostrings::PairwiseAlignments Pairwise Sequence Alignments
BSgenome::BSgenomeForge How to forge a BSgenome data package
BSgenome::GenomeSearching Efficient genome searching with Biostrings and the BSgenome data packages
Help files with alias or concept or title matching DNA using regular expression matching:
ade4::humDNAm human mitochondrial DNA restriction data
adegenet::$,genind-method Accessors for adegenet objects
adegenet::fasta2DNAbin Read large DNA alignments into R
adegenet::gengraph Genetic transitive graphs
adegenet::genlight Formal class "genlight"
adegenet::findMutations Identify mutations between DNA sequences
adegenet::DNAbin2genind Importing data from an alignement of sequences to a genind object
annotate::readGEOAnn Function to extract data from the GEO web site
ape::DNAbin Manipulate DNA Sequences in Bit-Level Format
ape::as.alignment Conversion Among DNA Sequence Internal Formats
ape::base.freq Base frequencies from DNA Sequences
ape::del.gaps Delete Alignment Gaps in DNA Sequences
ape::dist.dna Pairwise Distances from DNA Sequences
ape::image.DNAbin Plot of DNA Sequence Alignement
ape::makeLabel Label Management
ape::read.GenBank Read DNA Sequences from GenBank via Internet
ape::read.dna Read DNA Sequences in a File
ape::seg.sites Find Segregating Sites in DNA Sequences
ape::where Find Patterns in DNA Sequences
ape::write.dna Write DNA Sequences in a File
Biostrings::class:DNAString DNAString objects
Biostrings::class:MaskedXString MaskedXString objects
Biostrings::class:MultipleAlignment MultipleAlignment objects
Biostrings::class:PreprocessedTB PDict objects
Biostrings::class:QualityScaledXStringSet QualityScaledBStringSet, QualityScaledDNAStringSet,
QualityScaledRNAStringSet and QualityScaledAAStringSet objects
Biostrings::class:XString BString objects
Biostrings::class:XStringSet XStringSet objects
Biostrings::XStringSet-io Read/write an XStringSet object from/to a file
Biostrings::class:XStringSetList XStringSetList objects
Biostrings::class:XStringViews The XStringViews class
Biostrings::dinucleotideFrequencyTest Pearson's chi-squared Test and G-tests for String Position Dependence
Biostrings::findPalindromes Searching a sequence for palindromes or complemented palindromes
Biostrings::letterFrequency Calculate the frequency of letters in a biological sequence, or the
consensus matrix of a set of sequences
Biostrings::maxWeights PWM creating, matching, and related utilities
Biostrings::matchProbePair Find "theoretical amplicons" mapped to a probe pair
Biostrings::oligonucleotideFrequency Calculate the frequency of oligonucleotides in a DNA or RNA sequence
(and other related functions)
Biostrings::replaceLetterAt Replacing letters in a sequence (or set of sequences) at some
specified locations
Biostrings::reverse,MaskedXString-method Sequence reversing and complementing
Biostrings::toComplex Turning a DNA sequence into a vector of complex numbers
Biostrings::transcribe DNA/RNA transcription and translation
lubridate::ddays Quickly create exact time spans.
marray::boxplot,marrayRaw-method Boxplots for cDNA microarray spot statistics
marray::image,marrayRaw-method Color image for cDNA microarray spot statistics
marray::maBoxplot Boxplots for cDNA microarray spot statistics
marray::maImage Color image for cDNA microarray spot statistics
marray::maImage.func Color image for cDNA microarray spot statistics
marray::maNormMain Main function for location and scale normalization of cDNA microarray data
marray::maPlot Scatter-plots for cDNA microarray spot statistics
marray::marrayLayout-class Class "marrayLayout", classes and methods for layout parameters of
cDNA microarrays
marray::marrayNorm-class Class "marrayNorm", classes and methods for post-normalization cDNA
microarray intensity data
marray::marrayRaw-class Class "marrayRaw", classes and methods for pre-normalization cDNA
microarray intensity data
marray::plot.marrayRaw Scatter-plots for cDNA microarray spot statistics
marray::swirl Gene expression data from Swirl zebrafish cDNA microarray experiment
mlbench::DNA Primate splice-junction gene sequences (DNA)
nlme::Dim.pdMat Dimensions of a pdMat Object
nlme::coef.pdMat pdMat Object Coefficients
nlme::logDet.pdMat Extract Log-Determinant from a pdMat Object
nlme::pdConstruct Construct pdMat Objects
nlme::pdFactor Square-Root Factor of a Positive-Definite Matrix
nlme::pdMatrix Extract Matrix or Square-Root Factor from a pdMat Object
nlme::pdNatural General Positive-Definite Matrix in Natural Parametrization
nlme::solve.pdMat Calculate Inverse of a Positive-Definite Matrix
nlme::summary.pdMat Summarize a pdMat Object
phangorn::phyDat Conversion among Sequence Formats
RandomFields::RFMethods Simulation Techniques
RpsiXML::taxId Get or Set the NCBI Taxonomy ID or Organism Name
seqinr::SeqFastadna Class for DNA sequence in Fasta Format
seqinr::chargaff Base composition in ssDNA for 7 bacterial DNA
seqinr::dist.alignment Pairwise Distances from Aligned Protein or DNA/RNA Sequences
seqinr::getAnnot Generic Function to get sequence annotations
seqinr::getFrag Generic function to extract sequence fragments
seqinr::getLength Generic function to get the length of sequences
seqinr::getName Generic function to get the names of sequences
seqinr::getSequence Generic function to get sequence data
seqinr::getTrans Generic function to translate coding sequences into proteins
seqinr::n2s Function to convert the numeric encoding of a DNA sequence into
a vector of characters
seqinr::recstat Prediction of Coding DNA Sequences.
seqinr::s2n Simple numerical encoding of a DNA sequence.
sp::SpatialGrid-class Class "SpatialGrid"
sp::coordnames Retrieve or assign coordinate names for classes in sp
spatstat::[.hyperframe Internal spatstat functions
vsn::kidney Intensity data for 1 cDNA slide with two adjacent tissue samples
from a nephrectomy (kidney)
vsn::lymphoma Intensity data for 8 cDNA slides with CLL and DLBL samples from
the Alizadeh et al. paper in Nature 2000
BioSeqClass::featureBDNAVIDEO Feature Coding by DNA/RNA property
pls::coef.mvr Extract Information From a Fitted PLSR or PCR Model
base::factor Factors
base::getNativeSymbolInfo Obtain a Description of one or more Native (C/Fortran) Symbols
base::attachNamespace Loading and Unloading Name Spaces
datasets::DNase Elisa assay of DNase
La syntaxe de R est simple mais technique et le nombre de paramètres à utiliser est un frein à la compréhension. Heureusement, les valeurs par défaut simplifient l'utilisation.
seq() usage:
------------
seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
length.out = NULL, along.with = NULL, ...)
lm() usage:
------------
lm(formula, data, subset, weights, na.action,
method = "qr", model = TRUE, x = FALSE, y = FALSE, qr = TRUE,
singular.ok = TRUE, contrasts = NULL, offset, ...)
glm() usage:
------------
glm(formula, family = gaussian, data, weights, subset,
na.action, start = NULL, etastart, mustart, offset,
control = list(...), model = TRUE, method = "glm.fit",
x = FALSE, y = TRUE, contrasts = NULL, ...)
glm.fit() usage:
----------------
glm.fit(x, y, weights = rep(1, nobs),
start = NULL, etastart = NULL, mustart = NULL,
offset = rep(0, nobs), family = gaussian(),
control = list(), intercept = TRUE)
read.table() usage:
-------------------
read.table(file, header = FALSE, sep = "", quote = "\"'",
dec = ".", row.names, col.names,
as.is = !stringsAsFactors,
na.strings = "NA", colClasses = NA, nrows = -1,
skip = 0, check.names = TRUE, fill = !blank.lines.skip,
strip.white = FALSE, blank.lines.skip = TRUE,
comment.char = "#",
allowEscapes = FALSE, flush = FALSE,
stringsAsFactors = default.stringsAsFactors(),
fileEncoding = "", encoding = "unknown", text)
La syntaxe de R est simple, donc les calculs complexes peuvent se faire pas à pas à condition de "bien écrire" les instructions.
# au lieu de
return(paste(toupper(substr(chaine,1,1)),tolower(substr(chaine,2,nchar(chaine))),sep="")
# il vaut mieux écrire
longueurChaine <- nchar(chaine)
initiale <- substr(chaine,1,1)
initialeMaju <- toupper( initiale )
resteDeChaine <- substr(chaine,2,longueurChaine)
resteEnMinu <- tolower(resteDeChaine)
nvlChaine <- paste(initialeMaju,resteEnMinu,sep="")
return( nvlChaine )
# à éviter :
sprintf(outformat,round(100*(quantile(nomVar,0.75)-quantile(nomVar,0.25))/(quantile(nomVar,0.50))))
return(as.data.frame(read.table(fs,as.is=c(1))))
x <- return(c(mini,triRec(vect[-which(vect==mini)])))
moys <- matrix( lapply( X=split(x=pers$AGE,f=list(pers$SEXE,pers$ETUD)),FUN=mean ),ncol=length(levels(pers$ETUD)))
R est un langage puissant, concis et fonctionnel orienté traitement statistique, c'est pour cela qu'il est plus adapté que perl, php, python ou ruby pour réaliser des analyses statistiques.
# moyenne en colonne avec apply
cat(" apply : moyenne en colonne \n")
print(apply(X=mdata,MARGIN=2,FUN=mean))
# remarque : il existe une fonction pour cela, nommée colMeans()
# lapply de base : moyenne de chaque composante de la liste
cat("lapply de mean\n")
print(lapply(X=ldata,FUN=mean))
# lapply avec fonction anonyme pour gérer les NA
cat("lapply de mean avec na.rm=TRUE (solution 1)\n")
print(lapply(X=ldata,FUN=function(v) mean(v,na.rm=TRUE) ))
# mieux : lapply avec paramètre supplémentaire pour la fonction
cat("lapply de mean avec na.rm=TRUE (solution 2)\n")
print(lapply(X=ldata,FUN=mean,na.rm=TRUE)) # objet de classe "list"
R est orienté, entre autres, bioinformatique :
Help files with alias or concept or title matching NCBI using regular expression matching:
-----------------------------------------------------------------------------------------------------
annotate::accessionToUID A function to convert accession values to NCBI UIDs.
annotate::blastSequences Run a blast query to NCBI for either a string or an
entrez gene ID and then return a series of
MultipleAlignment objects.
annotate::getGI Queries the NCBI database to obtain the sequence for a given
GenBank Accession number
annotate::mapOrgs Functions to map to organism IDs used by NCBI homology.
AnnotationForge::makeOrgPackageFromNCBI Making an organism package from annotations available from NCBI.
AnnotationForge::populateDB Populates an SQLite DB with and produces a schema definition
CHNOSZ::taxonomy Extract Data from NCBI Taxonomy Files
Hmisc::dataDensityString Internal Hmisc functions
RpsiXML::taxId Get or Set the NCBI Taxonomy ID or Organism Name
seqinr::get.ncbi Bacterial complete genome data from ncbi ftp site
Help files with alias or concept or title matching PDB using regular expression matching:
-----------------------------------------------------------------------------------------------------
AnnotationDbi::AnnotationDb AnnotationDb objects and their progeny, methods etc.
AnnotationForge::available.db0pkgs available.db0pkgs
AnnotationForge::populateDB Populates an SQLite DB with and produces a schema definition
nlme::[.pdMat Subscript a pdMat Object
nlme::matrix<-.pdMat Assign Matrix to a pdMat Object
nlme::Names.pdBlocked Names of a pdBlocked Object
nlme::VarCorr Extract variance and correlation components
nlme::coef.pdMat pdMat Object Coefficients
nlme::corMatrix.pdBlocked Extract Correlation Matrix from a pdMat Object
nlme::formula.pdBlocked Extract pdBlocked Formula
nlme::isInitialized Check if Object is Initialized
nlme::logDet.pdMat Extract Log-Determinant from a pdMat Object
nlme::pdBlocked Positive-Definite Block Diagonal Matrix
nlme::pdConstruct.pdBlocked Construct pdBlocked Objects
nlme::pdFactor Square-Root Factor of a Positive-Definite Matrix
nlme::pdMatrix Extract Matrix or Square-Root Factor from a pdMat Object
nlme::solve.pdMat Calculate Inverse of a Positive-Definite Matrix
nlme::summary.pdMat Summarize a pdMat Object
UsingR::npdb National Practioner Data Bank
PFAM.db::PFAMPDB Mappings from a PFAM Accession number to a PDB ID
PFAM.db::PFAMPDB2AC Mappings from a PDB ID to a PFAM Accession number
Help files with alias or concept or title matching PFAM using regular expression matching:
-----------------------------------------------------------------------------------------------------
AnnotationDbi::ACCNUM Descriptions of available values for 'cols' and 'keytypes'.
Category::HyperGResult-accessors Accessors for HyperGResult Objects
Category::HyperGResult-class Class "HyperGResult"
Category::KEGGHyperGParams-class Class "KEGGHyperGParams" and "PFAMHyperGParams"
Category::categoryToEntrezBuilder Return a list mapping category ids to Entrez Gene ids
Category::hyperGTest Hypergeometric Test for association of categories and genes
Category::universeBuilder Return a vector of gene identifiers with category annotations
GSEABase::CollectionType-class Class "CollectionType"
GSEABase::CollectionType Collection Type Class Constructors
GSEABase::GeneSetCollection Methods to construct GeneSetCollection instances
hgu95av2.db::hgu95av2PFAM Map Manufacturer IDs to Pfam IDs
org.Hs.eg.db::org.Hs.egPFAM Map Entrez Gene IDs to Pfam IDs
org.Sc.sgd.db::org.Sc.sgdPFAM Map Entrez Gene IDs to Pfam IDs
ppiStats::ppiBuildParams4GO A wrapper function to build a parameter class for the input of the HyperGTest.
ppiStats::ppiHGTest4GO A wrapper function to implement the Hypergeometric test, HyperGTest
found withing the Category and GOstats packages.
BioSeqClass::featureDOMAIN Feature Coding by doamin organization
PFAM.db::PFAM.db Bioconductor annotation data package
PFAM.db::PFAMCAZY Mappings from a PFAM Accession number to another kind of ID
PFAM.db::PFAMMAPCOUNTS Number of mapped keys for the maps in package PFAM.db
PFAM.db::PFAMPDB Mappings from a PFAM Accession number to a PDB ID
PFAM.db::PFAMPDB2AC Mappings from a PDB ID to a PFAM Accession number
PFAM.db::PFAMCAZY2AC Mappings from an ID to a PFAM Accession number
PFAM.db::PFAMSCOP Mappings from a PFAM Accession number to a SCOP ID
PFAM.db::PFAMSCOP2AC Mappings from a SCOP ID to a PFAM Accession number
PFAM.db::PFAM_dbconn Collect information about the package annotation DB
Help files with alias or concept or title matching UniProt using fuzzy matching:
--------------------------------------------------------------------------------
AnnotationDbi::ACCNUM Descriptions of available values for 'cols' and 'keytypes'.
CHNOSZ::util.fasta Functions for Reading FASTA Files and Downloading from UniProt
GSEABase::GeneIdentifierType-class Class "GeneIdentifierType"
GSEABase::GeneIdentifierType Gene Identifier Class Constructors
hgu95av2.db::hgu95av2UNIPROT Map Uniprot accession numbers with Entrez Gene identifiers
org.Hs.eg.db::org.Hs.egUNIPROT Map Uniprot accession numbers with Entrez Gene identifiers
org.Sc.sgd.db::org.Sc.sgdUNIPROT Map Uniprot accession numbers with Systematic ORF identifiers
protr::getUniProt Get Protein Sequences from UniProt by Protein ID
RpsiXML::psimi25Source-class Class "psimi25Source"
RpsiXML::uniprot-methods Methods for Function uniprot in Package 'RpsiXML'
RpsiXML::uniprot The UniProt Identifier in the PSI-MI 2.5 XML file
RUnit::printTextProtocol Printing a plain text or HTML version of an RUnit test run protocol.
Comme inconvénient de R, il ne faut pas oublier de citer, comme en C, le problème de dépendance entre packages. Certains packages ont besoin d'autres packages pour fonctionner, voire de programmes C, Fortran, de compilateurs... pour être installés correctement. Il est donc conseillé d'utiliser le paramètre dependencies=TRUE de la commande install.packages() du package utils.
Un dernier inconvénient de R est l'hétérogénéité (parfois) de certaines syntaxes. Ainsi, il faut écrire help(package="gdata") mais ls("package:gdata") et detach("package:gdata") ; de même pour lapply(X=lst,FUN=nchar), sapply(X=lst,FUN=nchar) et rapply(object=lst,f=nchar).
Par contre la richesse de la syntaxe permet d'utiliser différents contextes :
# accès à la colonne AGE du data frame GENS, soit la colonne 5
age <- GENS[,5]
age <- GENS[,"AGE"]
age <- GENS$AGE
# en interactif, on peut demander le nom de la colonne
# à traiter, soit nomCol, et ensuite :
data <- GENS[,nomCol]
# par boucle on passe en revue toutes les colonnes
# lorsque indCol vaut 5, on a les données AGE :
data <- GENS[,indCol]
# en interactif, on veut rapidement utiliser AGE :
attach(GENS)
head(AGE)
9. Comparaison des différentes interfaces pour R
Quelles sont les différentes interfaces pour utiliser R ?
Lesquelles fournissent «juste un environnement de session» ?
Lesquelles sont dédiées aux analyses statistiques ?
Pour les commandes et les sessions R, il y a une interface minimale sans menu ni multi-fenétrage qui s'obtient via R sous Linux et via rterm.exe sous Windows. Une interface un peu plus élaborée avec menu et multi-fenétrage est disponible via R -g X11 et R -g tk sous Linux et via rgui.exe sous Windows. Toutefois, nous conseillons d'utiliser plutôt Rstudio qui est gratuit, lui aussi et disponible pour tous les systèmes d'exploitation. Voir la la rubrique «Avantages et inconvénients de l'interface standard (IS) et de l'interface de RStudio (RS)» de la note locale sur R pour comprendre pourquoi Rstudio est plus adapté à une utilisation régulière et surtout pourquoi il est le seul à permettre une production automatisée des rapports et articles. Ces interfaces fournissent «juste un environnement de session», ce qui signifie qu'elles n'aident en aucun cas à réaliser des analyses statistiques via les menus. Par contre, elles permettent, plus ou moins bien, de visualiser les données, de changer de répertoire, de sauvegarder l'historique des commandes, les variables de la session etc.
Pour réaliser des analyses statistiques (calculs et graphiques), il existe aussi des interfaces comme Rcommander, rkward et rattle. Une page très officielle pour de telles interfaces est sciviews.
Il peut être plus ou moins difficile d'installer ces interfaces qui, si elles se lancent via le chargement d'un package, font souvent appel à des exécutables extérieurs, à d'autres langages comme Tk, C, Fortran... et à des bibliothèques graphiques comme GTK.
A l'expérience, Rcommander, est assez agréable à utiliser avec des menus en français, rkward est assez complet et propose de nombreuses fenêtres de visualisation. Par contre, rattle est plus orienté data mining que statistiques. Il est conseillé de regarder la documentation de ces interfaces grâce aux liens ci-dessous afin de se faire une idée de ce qu'on peut en attendre, notamment via les copies d'écrans et les démonstrations...
S'il peut être rassurant d'utiliser une interface pour R, notamment au début pour découvrir les fonctions, nous ne conseillons pas de les utiliser dans le cadre d'une utilisations soutenue. La raison en est simple : pour reproduire des analyses et pour progresser, il faut avoir le code sous les yeux. Avec les interfaces, tout se fait par clic-souris et rien n'est automatisable. De plus seuls les paramètres les plus importants sont disponibles, et encore, pas forcément avec tous les choix possibles.
Il vaut donc mieux, selon nous, investir un peu plus dans la ligne de commande et l'écriture de scripts que de cliquer... Dans la mesure où les interfaces affichent les commandes exécutées via les menus, on apprend vite à écrire ce qu'on veut faire et à paramètrer avec des noms des fichiers différents...
Nous utiliserons de façon synoptique et comparative ces interfaces dans la séance 4, à l'exercice 2.
10. R versus les autres logiciels statistiques
Comment se situe R par rapport aux autres "grands logiciels statistiques" ?
Si R était au début un concurrent, R est maintenant un "plus" à interfacer pour les grands logiciels. Voir par exemple quelques arguments via la question 10 de notre cours EDA et la réponse associée.
Il est même possible d'utiliser R via Excel. Donc R peut servir de complément, notamment lorsque les autres logiciels sont déjà installés. Pour quelqu'un(e) habitué(e) à utiliser Statistica avec ses menus complets et dynamiques, ses sorties automatiques dans un fichier Word, sa paramétrisation programmée, R n'est sans doute pas si extraordinaire que cela, sauf pour la bioinformatique et pour sa capacité à automatiser et réactualiser les rapports et articles.
Pour un(e) professionel(le) de SAS, R a une syntaxe étrange (la réciproque est vraie). Heureusement, il existe des passerelles et des ouvrages qui permettent de passer de l'un à l'autre. SAS n'est donc plus indétronable pour la gestion automatisée "rapide" de rapports techniques pour de très gros volumes de données répartis sur la planète...
Ce qui caractérise les grands logiciels payants comme SAS et Statistica, hormis leur catalogue de formation et d'assistance aux utilisateurs
ce sont leurs possibilités de calculs, de graphiques, d'automatisation.
Seuls les logiciels
SAS et R sont capables de faire du
"big data"
c'est-à-dire de traiter de gros volumes de données,
disons quelques milliers de lignes et quelques centaines de colonnes,
puisqu'ils ne cherchent pas à afficher systématiquement les données.
On pourra par exemple consulter la page d'accueil de R Analytics.
De même, seuls
SAS et R sont capables de lire des fichiers disponibles sur le Web, d'avoir des systèmes de labels et de formats
automatisables pour fournir des versions multilingues des données et des résultats (voir, là encore notre cours EDA 5).
Par contre, à notre connaissance, seul R est réactif et fournit de nouvelles méthodes statistiques, de nouveaux graphiques, notamment en bioinformatique, en économie, et en économétrie. R devient ainsi une lingua franca selon le New York Times (2009). A titre de comparaison, la "nouvelle" version de SAS (pour 2013), nommée SAS 9.4 comporte de nombreux ajouts informatiques mais pas statistiques. Il faut toutefois signaler la tentative récente (2013) nommée SAS Visual Analytics centrée sur la visualisation des données.
Enfin, les diverses structures de données comme les listes, les vecteurs, les matrices et les data frames fournissent à R une souplesse et une grande cohésion en un seul langage que n'a pas, par exemple SAS qui ne dispose que d'une seule structure de données, les datasets et qui utilise cinq (!) langages propriétaires, à savoir SAS L, SAS ML, SAS IML, SAS DS2, SAS FedSQL.
11. Cours de R en ligne et en français
Y a-t-il beaucoup de cours de R en ligne et en français ? Et de manuels au format PDF ?
Oui, bien sûr, d'autant plus que de plus en plus d'enseignants utilisent R.
S'il ne fallait choisir qu'un seul document, ce serait celui d'E. Paradis. Il est suffisamment complet pour fournir une revue générale de R sous l'angle des données, des calculs, des graphiques... en 80 pages.
S'il ne fallait retenir qu'un seul site avec des exercices corrigés, ce serait pbil/R ; on y trouve notamment un Rweb qui permet d'exécuter du code R dans un navigateur...
Pour des listes de livres sur R, consulter la solution 14 de notre cours de Programmation avancée en R, tout en sachant que la majorité des ouvrages sont en anglais, comme on peut le voir à l'énoncé 14 de ce même cours.
Code-source php de cette page ; code javascript utilisé. Retour à la page principale du cours.
|
Retour à la page principale de
(gH)