Commit 232b6a86 authored by Laurence Viry's avatar Laurence Viry
Browse files

modif manipDon

parent 4f64f424
......@@ -19,18 +19,18 @@
"\n",
"## Importer des données\n",
"\n",
"Les données sont initialement collectées, éventuellement prétraitées par un logiciel. \n",
"Les données sont initialement collectées, syckées sous différents formats, éventuellement prétraitées par un logiciel ou extraites d'une base de données. \n",
"\n",
"Chaque logiciel ayant son propre format de stockage, le plus simple est souvent d'échanger les données par un format commun à tous, **le format texte** ( .csv par exemple).\n",
"Chaque logiciel ayant son propre format de stockage, le plus simple est souvent d'échanger les données par un format commun à tous qui sera le plus souvent **le format texte** ( .csv par exemple).\n",
"\n",
"On peut également utiliser **les formats propriétaires** des autres logiciels en utilisant un package adapté (le package foreign par exemple), le choix dépendant du contexte et du volume des données.\n",
"On peut également utiliser **les formats propriétaires** des autres logiciels en utilisant un package adapté (le package **foreign** par exemple), le choix dépendant du contexte et du volume des données.\n",
"\n",
"### Cas des fichiers **csv** \n",
"\n",
"Les avantages des fichiers **csv**:\n",
"\n",
" - Peut être lu par n'importe quel logiciel passé, présent et probablement futur,\n",
" - Pour la compatibilité entre plate-forme (Windows, Mac, Linux),\n",
" - Peut être lu par n'importe quel logiciel passé, présent et probablement futur.\n",
" - Pour la compatibilité entre plate-forme (Windows, Mac, Linux).\n",
" - Pour la facilité de lecture par un être humain comparativement à d'autres formats tels que XML, HL7, JSON etc.\n",
"\n",
"**Mais** pas forcément adapté aux gros volumes de données pour son volume de stockage et la rapidité de lecture.\n",
......@@ -47,37 +47,22 @@
},
{
"cell_type": "code",
"execution_count": 1,
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"'/home/viryl/notebooks/CED-IntroR/notebooks'"
"'/home/viryl/notebooks/ATMO_IntroR/notebooks'"
],
"text/latex": [
"'/home/viryl/notebooks/CED-IntroR/notebooks'"
"'/home/viryl/notebooks/ATMO\\_IntroR/notebooks'"
],
"text/markdown": [
"'/home/viryl/notebooks/CED-IntroR/notebooks'"
"'/home/viryl/notebooks/ATMO_IntroR/notebooks'"
],
"text/plain": [
"[1] \"/home/viryl/notebooks/CED-IntroR/notebooks\""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
" taille poids pointure sexe \n",
" Min. :158.0 Min. :72.00 Min. :42.0 M:3 \n",
" 1st Qu.:166.8 1st Qu.:75.00 1st Qu.:42.5 \n",
" Median :175.5 Median :78.00 Median :43.0 \n",
" Mean :172.5 Mean :76.67 Mean :43.0 \n",
" 3rd Qu.:179.8 3rd Qu.:79.00 3rd Qu.:43.5 \n",
" Max. :184.0 Max. :80.00 Max. :44.0 "
"[1] \"/home/viryl/notebooks/ATMO_IntroR/notebooks\""
]
},
"metadata": {},
......@@ -100,14 +85,29 @@
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
" taille poids pointure sexe \n",
" Min. :158.0 Min. :72.00 Min. :42.0 M:3 \n",
" 1st Qu.:166.8 1st Qu.:75.00 1st Qu.:42.5 \n",
" Median :175.5 Median :78.00 Median :43.0 \n",
" Mean :172.5 Mean :76.67 Mean :43.0 \n",
" 3rd Qu.:179.8 3rd Qu.:79.00 3rd Qu.:43.5 \n",
" Max. :184.0 Max. :80.00 Max. :44.0 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Lecture du fichier donnees.csv\n",
"getwd() # repertoire de travail\n",
"don <- read.csv(file = \"data/donnees.csv\",header=TRUE,sep=\";\",dec=\",\",row.names=1)\n",
"summary(don)\n",
"class(don)"
"class(don)\n",
"summary(don)"
]
},
{
......@@ -116,7 +116,7 @@
"source": [
" - l'argument **sep** : indique que les valeurs sont séparées par **\";\"** (**\" \"** pour un espace, **\"\\t\"** pour une tabulation)\n",
" - l'argument **dep** : indique que le séparateur de décimal est **\",\"**\n",
" - l'argument **header**: indique si la première ligne contient les noms des variables (TRUE) ou non(FALSE).\n",
" - l'argument **header** : indique si la première ligne contient les noms des variables (TRUE) ou non(FALSE).\n",
" - l'argument **row.names** : indique que la colonne 1 n'est pas une variable mais l'identifiant des individus.\n",
" "
]
......@@ -132,16 +132,181 @@
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" taille poids pointure sexe \n",
" Min. :100.0 Min. :15 Min. :22.00 F :2 \n",
" 1st Qu.:110.0 1st Qu.:30 1st Qu.:30.50 M :3 \n",
" Median :160.0 Median :72 Median :40.00 NA's:1 \n",
" Mean :145.9 Mean :55 Mean :36.17 \n",
" 3rd Qu.:175.5 3rd Qu.:78 3rd Qu.:42.75 \n",
" Max. :184.0 Max. :80 Max. :44.00 \n",
" NA's :1 NA's :1 "
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"'list'"
],
"text/latex": [
"'list'"
],
"text/markdown": [
"'list'"
],
"text/plain": [
"[1] \"list\""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"'data.frame'"
],
"text/latex": [
"'data.frame'"
],
"text/markdown": [
"'data.frame'"
],
"text/plain": [
"[1] \"data.frame\""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<dl>\n",
"\t<dt>$names</dt>\n",
"\t\t<dd><ol class=list-inline>\n",
"\t<li>'taille'</li>\n",
"\t<li>'poids'</li>\n",
"\t<li>'pointure'</li>\n",
"\t<li>'sexe'</li>\n",
"</ol>\n",
"</dd>\n",
"\t<dt>$class</dt>\n",
"\t\t<dd>'data.frame'</dd>\n",
"\t<dt>$row.names</dt>\n",
"\t\t<dd><ol class=list-inline>\n",
"\t<li>'roger'</li>\n",
"\t<li>'theodule'</li>\n",
"\t<li>'nicolas'</li>\n",
"\t<li>'Alice'</li>\n",
"\t<li>'Marcel'</li>\n",
"\t<li>'Claire'</li>\n",
"</ol>\n",
"</dd>\n",
"</dl>\n"
],
"text/latex": [
"\\begin{description}\n",
"\\item[\\$names] \\begin{enumerate*}\n",
"\\item 'taille'\n",
"\\item 'poids'\n",
"\\item 'pointure'\n",
"\\item 'sexe'\n",
"\\end{enumerate*}\n",
"\n",
"\\item[\\$class] 'data.frame'\n",
"\\item[\\$row.names] \\begin{enumerate*}\n",
"\\item 'roger'\n",
"\\item 'theodule'\n",
"\\item 'nicolas'\n",
"\\item 'Alice'\n",
"\\item 'Marcel'\n",
"\\item 'Claire'\n",
"\\end{enumerate*}\n",
"\n",
"\\end{description}\n"
],
"text/markdown": [
"$names\n",
": 1. 'taille'\n",
"2. 'poids'\n",
"3. 'pointure'\n",
"4. 'sexe'\n",
"\n",
"\n",
"\n",
"$class\n",
": 'data.frame'\n",
"$row.names\n",
": 1. 'roger'\n",
"2. 'theodule'\n",
"3. 'nicolas'\n",
"4. 'Alice'\n",
"5. 'Marcel'\n",
"6. 'Claire'\n",
"\n",
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
"$names\n",
"[1] \"taille\" \"poids\" \"pointure\" \"sexe\" \n",
"\n",
"$class\n",
"[1] \"data.frame\"\n",
"\n",
"$row.names\n",
"[1] \"roger\" \"theodule\" \"nicolas\" \"Alice\" \"Marcel\" \"Claire\" \n"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"[1] NA"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"55"
],
"text/latex": [
"55"
],
"text/markdown": [
"55"
],
"text/plain": [
"[1] 55"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"don2 <- read.csv(file = \"data/don2.csv\",header=TRUE,sep=\";\",dec=\",\",row.names=1,na.strings=\"***\")\n",
"summary(don2)\n",
"mode(don2)\n",
"class(don2)\n",
"attributes(don2)\n",
"mean(don2$poids)\n",
"mean(don2$poids,na.rm=TRUE)"
]
},
......@@ -154,21 +319,40 @@
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" SCORE TIME DECIMAL.TIME CLASS \n",
" Min. : 6.0 03:22:50:1 Min. :0.140 BEST :2 \n",
" 1st Qu.: 8.0 07:42:51:1 1st Qu.:0.320 INTERMEDIATE:1 \n",
" Median :13.0 09:30:03:1 Median :0.400 WORST :2 \n",
" Mean :12.4 12:01:03:1 Mean :0.372 \n",
" 3rd Qu.:16.0 12:01:29:1 3rd Qu.:0.500 \n",
" Max. :19.0 Max. :0.500 "
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"decath <- read.table(\"http://www.agrocampus-ouest.fr/math/livreR/decathlon.csv\",header=TRUE,sep=\";\",row.names=1)\n",
"summary(decath)"
"df <- read.table(\"https://s3.amazonaws.com/assets.datacamp.com/blog_assets/scores_timed.csv\",header=TRUE,row.names = 1,sep = \",\")\n",
"summary(df)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonctions utiles dans un data-frame\n",
"#### Fonctions utiles dans un data-frame\n",
"\n",
"* **head()** - pour voir les 6 premières lignes \n",
"* **tail()** - pour voir les 6 dernières lignes \n",
......@@ -177,8 +361,26 @@
"* **ncol()** - le nombre de colonnes \n",
"* **str()** - structure de chaque colonne\n",
"* **names()** - liste l'attribut **names** d'un data.frame (ou n'importe quel autre objet), les noms des colonnes\n",
"* **dimnanes()** - liste l'attribut **row.names** d'un data.frame.\n",
"\n",
"* **dimnanes()** - liste l'attribut **row.names** d'un data.frame."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"str(df)\n",
"names(df)\n",
"nrow(df)\n",
"ncol(df)\n",
"dimnames(df)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### La fonction **scan**\n",
"\n",
"La fonction **scan** est plus flexible que **read.table**.\n",
......@@ -188,7 +390,7 @@
},
{
"cell_type": "code",
"execution_count": null,
"execution_count": 13,
"metadata": {
"collapsed": true
},
......@@ -226,6 +428,13 @@
"Pour en savoir plus **help(scan)**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Cas des fichiers Excel"
]
},
{
"cell_type": "markdown",
"metadata": {},
......
%% Cell type:markdown id: tags:
# Manipuler des données dans R
En statistique, les données constituent le point de départ de toute analyse, un premier travail de mise en forme de ces données est presque toujours indispensable. Il faudra savoir maitriser des opérations comme:
* Importation de données sous différents formats,
* exporter des données et des résultats sous différents formats,
* concaténer ou extraire des données,
* repérer les individus ayant des données manquantes ou aberrantes.
* changer le type de certaines variables pour les adapter aux traitements envisagés,
* $\ldots$
R fournit des outils et des capacités de programmation pour effectuer ces différentes tâches.
## Importer des données
Les données sont initialement collectées, éventuellement prétraitées par un logiciel.
Les données sont initialement collectées, syckées sous différents formats, éventuellement prétraitées par un logiciel ou extraites d'une base de données.
Chaque logiciel ayant son propre format de stockage, le plus simple est souvent d'échanger les données par un format commun à tous, **le format texte** ( .csv par exemple).
Chaque logiciel ayant son propre format de stockage, le plus simple est souvent d'échanger les données par un format commun à tous qui sera le plus souvent **le format texte** ( .csv par exemple).
On peut également utiliser **les formats propriétaires** des autres logiciels en utilisant un package adapté (le package foreign par exemple), le choix dépendant du contexte et du volume des données.
On peut également utiliser **les formats propriétaires** des autres logiciels en utilisant un package adapté (le package **foreign** par exemple), le choix dépendant du contexte et du volume des données.
### Cas des fichiers **csv**
Les avantages des fichiers **csv**:
- Peut être lu par n'importe quel logiciel passé, présent et probablement futur,
- Pour la compatibilité entre plate-forme (Windows, Mac, Linux),
- Peut être lu par n'importe quel logiciel passé, présent et probablement futur.
- Pour la compatibilité entre plate-forme (Windows, Mac, Linux).
- Pour la facilité de lecture par un être humain comparativement à d'autres formats tels que XML, HL7, JSON etc.
**Mais** pas forcément adapté aux gros volumes de données pour son volume de stockage et la rapidité de lecture.
R lit des données en format texte avec les fonctions **read.table()**,**read.csv()**,**scan()**,**read.fwf()**,$\ldots$
* Le fichier "donnees.csv" est stocké dans le répertoire data sitée dans le répertoire de travail
- pour connaître le répertoire de travail, utiliser la fonction **getwd()**
- pour définir le répertoire de travail, la fonction **setwd()**
Le résultat de la fonction **read.table** ou **read.csv** est de type **data-frame**.
%% Cell type:code id: tags:
``` R
# Lecture du fichier donnees.csv
getwd() # repertoire de travail
don <- read.csv(file = "data/donnees.csv",header=TRUE,sep=";",dec=",",row.names=1)
summary(don)
class(don)
summary(don)
```
%%%% Output: display_data
'/home/viryl/notebooks/CED-IntroR/notebooks'
'/home/viryl/notebooks/CED-IntroR/notebooks'
'/home/viryl/notebooks/ATMO_IntroR/notebooks'
'/home/viryl/notebooks/ATMO\_IntroR/notebooks'
%%%% Output: display_data
'data.frame'
'data.frame'
%%%% Output: display_data
'data.frame'
'data.frame'
%% Cell type:markdown id: tags:
- l'argument **sep** : indique que les valeurs sont séparées par **";"** (**" "** pour un espace, **"\t"** pour une tabulation)
- l'argument **dep** : indique que le séparateur de décimal est **","**
- l'argument **header**: indique si la première ligne contient les noms des variables (TRUE) ou non(FALSE).
- l'argument **header** : indique si la première ligne contient les noms des variables (TRUE) ou non(FALSE).
- l'argument **row.names** : indique que la colonne 1 n'est pas une variable mais l'identifiant des individus.
%% Cell type:markdown id: tags:
* Un caractère spécial peut indiquer qu'il y a des données manquantes:
Le fichier **don2.csv** contient des données manquantes codées **"\*\*\*"**, on ajoute l'argument **na.strings**
%% Cell type:code id: tags:
``` R
don2 <- read.csv(file = "data/don2.csv",header=TRUE,sep=";",dec=",",row.names=1,na.strings="***")
summary(don2)
mode(don2)
class(don2)
attributes(don2)
mean(don2$poids)
mean(don2$poids,na.rm=TRUE)
```
%%%% Output: display_data
%%%% Output: display_data
'list'
'list'
%%%% Output: display_data
'data.frame'
'data.frame'
%%%% Output: display_data
$names
: 1. 'taille'
2. 'poids'
3. 'pointure'
4. 'sexe'
$class
: 'data.frame'
$row.names
: 1. 'roger'
2. 'theodule'
3. 'nicolas'
4. 'Alice'
5. 'Marcel'
6. 'Claire'
\begin{description}
\item[\$names] \begin{enumerate*}
\item 'taille'
\item 'poids'
\item 'pointure'
\item 'sexe'
\end{enumerate*}
\item[\$class] 'data.frame'
\item[\$row.names] \begin{enumerate*}
\item 'roger'
\item 'theodule'
\item 'nicolas'
\item 'Alice'
\item 'Marcel'
\item 'Claire'
\end{enumerate*}
\end{description}
%%%% Output: display_data
%%%% Output: display_data
55
55
%% Cell type:markdown id: tags:
* Le chemin peut-être une URL:
%% Cell type:code id: tags:
``` R
decath <- read.table("http://www.agrocampus-ouest.fr/math/livreR/decathlon.csv",header=TRUE,sep=";",row.names=1)
summary(decath)
df <- read.table("https://s3.amazonaws.com/assets.datacamp.com/blog_assets/scores_timed.csv",header=TRUE,row.names = 1,sep = ",")
summary(df)
```
%%%% Output: display_data
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
### Fonctions utiles dans un data-frame
#### Fonctions utiles dans un data-frame
* **head()** - pour voir les 6 premières lignes
* **tail()** - pour voir les 6 dernières lignes
* **dim()** - ses dimensions
* **nrow()** - le nombre de lignes
* **ncol()** - le nombre de colonnes
* **str()** - structure de chaque colonne
* **names()** - liste l'attribut **names** d'un data.frame (ou n'importe quel autre objet), les noms des colonnes
* **dimnanes()** - liste l'attribut **row.names** d'un data.frame.
%% Cell type:code id: tags:
``` R
str(df)
names(df)
nrow(df)
ncol(df)
dimnames(df)
```
%% Cell type:markdown id: tags:
### La fonction **scan**
La fonction **scan** est plus flexible que **read.table**.
* Une différence est qu'il est possible de spécifier le mode des variables:
%% Cell type:code id: tags:
``` R
help(scan)
```
%% Cell type:code id: tags:
``` R
mydata <- scan("data/don.txt",skip=1,what = list("", 0, 0,0))
class(mydata)
mydata[[1]] # premiere variable
mydata[[1]][1] #
```
%% Cell type:markdown id: tags:
Dans cet exemple, scan lit 4 variables, la première de mode caractère et les trois suivantes sont de mode numérique.
**myDat** est une liste de 4 vecteurs.
* scan() peut être utilisée pour créer des objets de mode différent (vecteurs, matrices, tableaux de données, listes,...).
*
* Par défaut, c'est-à-dire si what est omis, scan() crée un vecteur numérique.
Pour en savoir plus **help(scan)**
%% Cell type:markdown id: tags:
### Cas des fichiers Excel
%% Cell type:markdown id: tags:
### Les formats propriétaires
R peut également lire des fichiers dans d'autres formats (**Excel, SAS, SPSS**,$\ldots$) et accéder à des **bases de données**.
* Le package **foreign** permet d'importer des données en format propriétaire binaire tels que **Stata, SAS, SPSS, etc**.
**library**(foreign) <br\>
**read.dta**("calf pneu.dta") # for Stata files<br\>
**read.xport**("file.xpt") # for SAS XPORT format<br\>
**read.spss**("file.sav") # for SPSS format<br\>
**read.mpt**("file.mtp") # for Minitab Portable Worksheet<br\>
Une autre solution pour des **fichiers SPSS**, le package **Hmisc**<br\>
### Base de données relationnelles et autres formats
Certains packages permettent de se connecter directement sur des bases de données de type **MySQL** ou **PostgreSQL**
(MongoDB,Redis,ousqlite,...). Dans ce cas,le mode d’interaction avec les données est légèrement différent
car on utilise alors le langage de requête propre au langage, à moins d’utiliser des packages qui permettent d’assurer
la conversion à partir des commandes R habituelles telles que **subset()**.
Pour en savoir plus :
* [Cookbook for R](http://www.cookbook-r.com/Manipulating_data/)
%% Cell type:markdown id: tags:
## Sauvegarder des données ou des résultats
Une fois les analyses effectuées et les résultats obtenus, il est souvent important de les sauvegarder pour les communiquer à d'autres personnes ou d'autres logiciels ou les réutiliser dans d'autres analyses.
### En format texte
Le format texte est fréquemment le format utilisé en utilisant la fonction **write.table()**.
%% Cell type:code id: tags:
``` R
tablo_res <- matrix(runif(40), ncol=4)
# sauvegarde les resulatts dans le repertoire resultat
setwd("/home/viryl/notebooks/CED-IntroR/resultat")
write.table(tablo_res,"monfichier.csv",sep=";",row.names=FALSE)
getwd()
```
%% Cell type:markdown id: tags:
### En format binaire RData
* Exporter les résultats et/ou les données dans un fichier binaire suffixé
**.Rdata** que R sera capable de décrypter par la suite grâce à la fonction **save()**
**save(file="nom du fichier",liste des variables)** (help(save))
%% Cell type:code id: tags:
``` R
x <- runif(20)
y <- list(a = 1, b = TRUE, c = "oops")
getwd()
save(x, y, file = "xy.RData")
```
%% Cell type:markdown id: tags:
* L'utilisation des fichiers sauvegardées par la commande **save()** se fait par la commande **load()**.
%% Cell type:code id: tags:
``` R
rm(list=ls())
"avant load"
ls()
load(file="xy.RData")
"après load"
ls()
```
%% Cell type:markdown id: tags:
## Manipuler des variables
* **Changer le type d'une variable**: à l'issue d'une importation, une variable qualitative dont les modalitées sont numériques sera comprise par R comme une variable quantitative,$\ldots$
* **Découper en classes une variable quantitative**: le passage d'une variable quantitative à une variable qualitative est fréquemment nécessaire en statistiques pour l'adapter à la méthode utilisée (AFC,AFCM,$\ldots$)
* **Modifier les niveaux d'une variable qualitative**: fusionner un ou plusieurs niveaux en fonction des effectifs,$\ldots$
* **Repérer les données manquantes**: permettre la prise en compte des données manquantes dans le traitement statistique des données.
* **Repérer les données aberrantes**: permettre la prise en compte des données aberrantes dans le traitement statistique des données.
* $\ldots$
### Quantitatives ou qualitative?
Trois méthodes:
%% Cell type:code id: tags:
``` R
# on genere une variable X
X <-c(rep(5,2),rep(12,4),13)
X
# Une variable qualitative?
Xq <is.factor(X)
# Une variable quantitative
is.numeric(X)
# Statistques descriptives
summary(X)
```
%% Cell type:markdown id: tags:
Les trois instructions nous indiquent que X est une variable quantitative.
%% Cell type:markdown id: tags:
### Variable qualitative vers variable quantitative
* Avec recodification des modalités: 1 seule étape
Par défaut, la conversion d'un facteur en variable quantitative, utilise la recodification des modalités à **1 to nlevels(x)**
%% Cell type:code id: tags:
``` R
Xqual <- factor(c(rep(5,2),seq(0,6,by=2),13))
Xqual
nlevels(Xqual)
summary(Xqual)
is.factor(Xqual)
as.numeric(Xqual)
```
%% Cell type:markdown id: tags:
* Sans recodification des modalités
Si on veut éviter la recofication, lorsque la valeur des modalités a un sens de quantité, il sera nécessaire de faire une première conversion de mode en mode **"character"**, avant la conversion en **"numeric"**.
%% Cell type:code id: tags:
``` R
Xqual
prov <- as.character(Xqual)
prov
Xquant <- as.numeric(prov) # as.numeric(as.character(Xqual))
Xquant
summary(Xquant)
```
%% Cell type:markdown id: tags:
### Variable quantitative vers variable qualitative
* En conservant les valeurs de la variable quantitative
%% Cell type:code id: tags:
``` R
rm(list=ls())
ls()
X <- seq(0,10,2)
X
summary(X)
Xqual <- as.factor(X)
Xqual
summary(Xqual)
```
%% Cell type:markdown id: tags:
### Découpage en classes d'une variable quantitative
Le découpage en classes d'une variable quantitatives peut se faire avec **deux approches**:
* Les **seuils des classes** sont choisis par les utilisateurs: pour définir ces seuils de façon automatique, on utilisera la fonction **cut**. Les bornes des intervals sont fournies à la fonction cut, les classes sont de la forme $\bf{] a_i,a_{i+1}]}$.
%% Cell type:code id: tags:
``` R
set.seed(654) # on fixe la graine du generateur
X <- rnorm(n=100,mean=0,sd=1)
# Decoupage en 3 niveaux: [min(X),-0.2],[-0.2,0.2],[0.2,max(X)]
Xqual <- cut(X,breaks = c(min(X)-1e-10,-0.2,0.2,max(X)))
class(Xqual)
table(Xqual)
summary(Xqual) # ou table(Xqual)
```
%% Cell type:markdown id: tags:
On indique "$min(X)-1e-10$" pour que le minimum appartienne à la classe.
* Un découpage automatique proposant **des effectifs équivalents dans chaque classes**: si nous voulons des effectifs équilibrés dans chacune des trois modalités, on utilisera la **fonction quantile**.
%% Cell type:code id: tags:
``` R
decoupe <- quantile(X,probs=seq(0,1,length=4))
decoupe
decoupe[1] <- decoupe[1]-1e-10
Xqual <- cut(X,decoupe)
table(Xqual)
```
%% Cell type:markdown id: tags:
### Modifier les modalités d'un facteur
* Modifier les labels des modalités
%% Cell type:code id: tags:
``` R
Xqual <- cut(X,decoupe)
levels(Xqual)
#Xqual
table(Xqual)
#
levels(Xqual) <- c(1,2,3) # modification les labels des modalités
#Xqual
table(Xqual)
```
%% Cell type:markdown id: tags:
* Fusionner un ou plusieurs niveaux
%% Cell type:code id: tags:
``` R
levels(Xqual)
levels(Xqual) <- c(1,2,1)
levels(Xqual)
table(Xqual)
```
%% Cell type:markdown id: tags:
* Définir un niveau de référence: pour certaines méthodes, il faudra tenir compte de l'ordre d'apparition des niveaux ou spécifier une niveau de référence (analyse de variance,$\ldots$), on utilise la fonction **relevel**:
%% Cell type:code id: tags:
``` R
X <- c(1,2,1,3,2,2,1)
Xqual <- factor(X,label=c("classique","nouveau","placebo"))
levels(Xqual)
Xqual2 <- relevel(Xqual,ref="placebo")
levels(Xqual2)
```
%% Cell type:markdown id: tags:
* Contrôler l'ordre des niveaux: recréer un facteur à partir du facteur existant en spécifiant l'ordre des niveaux.
%% Cell type:code id: tags:
``` R
table(Xqual)
Xqual3 <- factor(Xqual,levels=c("placebo", "nouveau","classique"))
Xqual3 <- Xqual3[-4] # elimine l'individu avec la modalite "3"
#Xqual3
table(Xqual3) # la modalite "3" n'apparait plus
# elimine la modalite "3"
Xqual3 <- factor(as.character(Xqual3)) # elimine la modalite "3"
table(Xqual3)
```
%% Cell type:markdown id: tags:
## Manipuler des individus
### Repérer les individus manquants
Dans R, les données manquantes sont représentées par **NA**. La fonction **is.na**
permet de les retrouver.
* Dans une variable:
%% Cell type:code id: tags:
``` R
X <- rnorm(10,0,1)
X[c(2,7,10)] <- NA
summary(X)
mean(X)
mean(X,na.rm=TRUE)
#
selectNA <- is.na(X)
selectNA
which(selectNA) # Quels sont les indices correspondants
# "!" : negation
X2 <-X[!selectNA] # On élimine les individus correspondants
```
%% Cell type:markdown id: tags:
* Dans sun tableau de données:
%% Cell type:code id: tags:
``` R
Y <- factor(c(rep("A",3),NA,rep("M",4),"D",NA))
# data-frame avec les deux variables X et Y
don <-data.frame(X,Y)
summary(don)
#
selectNA <- is.na(don)
#mode(selectNA)
class(selectNA)
#selectNA
#
# au moins une donnee manquante pour un individu
aelim_any <- apply(selectNA, MARGIN=1,FUN=any)
aelim_any
# Toutes les donnees sont manquantes pour un individu
aelim_all <- apply(selectNA, MARGIN=1,FUN=all)
aelim_all
```
%% Cell type:code id: tags:
``` R
don2 <-don[!aelim_all,] # individus élimines
which(is.na(don))
which(is.na(don),arr.ind=T) # option arr.ind (array indices) de which
```
%% Cell type:markdown id: tags:
### Repérer les individus aberrants
%% Cell type:markdown id: tags:
On utilise la fonction boxplot qui fournit dans sa composante out les valeurs
aberrantes.
Dans l'exemple, on utilise le package "rpart", vous pouvez l'installer en local, voir ~/Utils/install_local_package.ipynb
%% Cell type:code id: tags:
``` R
rm(list=ls())
```
%% Cell type:code id: tags:
``` R