You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Vous ne pouvez pas être passé à côté de cette notion. Cela fait plusieurs années qu'on entend parler de BIG DATA. En tant que biologiste, vous n'allez pas devoir employer quotidiennement les outils associés au big data. Vous allez cependant être confronté à de larges tableaux de données ou encore à des bases de données. Il est de fait important de connaitre les notions de base pour traiter ce genre d'information. Ce tutoriel vous permettra de :
63
+
64
+
- Choisir le format et la compression d'un fichier en fonction de vos besoins
65
+
- Réaliser des requêtes sur une base de données
36
66
37
67
## Fichiers CSV compressés
38
68
39
-
TODO...
69
+
Un fichier CSV "comma-separated-values" est un fichier textuel adaptée en données tabulaires. Chaque ligne de ce fichier va représenter une ligne d'un tableau de données. Généralement, les colonnes vont être spécifiées à l'aide d'une virgule. Il existe également une variante avec le point-virgule. Ce format est très employé et conseillé afin d'encoder des tableaux de données.
70
+
71
+
Cette première section est un plus théorique afin de vérifier que vous maîtriser les notions clés dans l'utilisation d'un fichier csv et de ces versions compressées.
72
+
73
+
```{r qu_csv}
74
+
quiz(
75
+
question("Dans le cadre d'une collaboration entre plusieurs chercheurs étrangers travaillant sur un même tableau de données de petite taille, mais utilisant de langages différents (python, R,...), quel format est à privilégier ? ",
76
+
answer("csv", correct = TRUE,
77
+
message = "Ce format est simple et très pratique. Il ne faut pas un logiciel particulier pour l'ouvrir. Il est très répandu dans la communauté scientifique. Il s'agit du bon choix pour collaborer à condition d'avoir un fichier peu volumineux."),
78
+
answer("xlsx",
79
+
message = "Ce format est préférable au format xls. Il n'est cependant pas le meilleur pour collaborer avec des personnes n'utilisant pas forcément Microsoft Excel."),
80
+
answer("xls",
81
+
message = "Il s'agit d'un format propre à Microsoft Excel. Ce format est plus ancien que xlsx. Si vous devez employer xls ou xlsx, nous vous conseillons d'utiliser xslx."),
82
+
answer("rds",
83
+
message = "Ce format est un format spécifique à R. De plus, il est déconseillé de l'employer dans le partage de données."),
84
+
allow_retry = TRUE,
85
+
random_answer_order = TRUE),
86
+
question("Quel format utiliser afin d'archiver un tableau de données dont l'objectif est de réduire sa taille au maximum ?",
87
+
answer("csv",
88
+
message = "Ce format n'est pas compressé. Il a de nombreux avantages, mais il n'est pas la meilleure solution afin d'archiver un fichier."),
89
+
answer("csv.bz2",
90
+
message = "Ce format est une forme de compromis entre un fichier non compressé et un fichier très compressé."),
91
+
answer("csv.gz",
92
+
message = "Ce format est une forme de compromis entre un fichier non compressé et un fichier très compressé."),
93
+
answer("csv.xz", correct = TRUE,
94
+
message = "La compression xz permet de compresser un csv de plus de 3 fois. C'est très efficace. Si l'objectif est de compresser un maximum afin d'archiver un fichier, c'est le format recommandé."),
95
+
allow_retry = TRUE,
96
+
random_answer_order = TRUE)
97
+
)
98
+
```
99
+
100
+
Le format csv ne semble pas être près de disparaitre de sitôt. Sa grande simplicité et sa facilité d'accès en font sa grande force. De nouveaux formats apparaissent cependant régulièrement, nous pouvons par exemple citer `feather` qui est disponible dans le package du même nom qui propose un format parfaitement compatible entre R, Python et Julia. Ce format est un fichier binaire. Il n'est pas lisible comme un csv. On peut également citer le format `parquet` que l'on retrouve dans le package {arrow}.
40
101
41
102
## Initiation au langage SQL
42
103
43
-
TODO: ce tutoriel doit encore être écrit. Vous devez probablement penser à installer une version plus récente du package qui contient les exercices finalisés !
104
+
Cette section va vous permettre de vous initier au langage SQL, mais pas de panique. Il ne va pas vous falloir apprendre un tout nouveau langage. Nous pouvons nous appuyer sur le package {dbplyr} afin d'employer les verbes que nous connaissons bien et de faire une sélection sur les colonnes, un filtre sur les lignes, un regroupement en fonction d'une colonne d'intérêt...
105
+
106
+
Cette section va se baser sur un jeu de données que vous connaissez qui va être converti en base de données duckdb pour vous permettre de vous exercer sur les bases de données. Dans un cas plus réaliste, vous devriez vous connecter à une base de données distantes, réaliser vos filtres et sélections et ne récupérer qu'une petite partie des données.
107
+
108
+
```{r, echo = TRUE}
109
+
diabetes_db
110
+
dbListTables(diabetes_db)
111
+
dbListFields(diabetes_db, "blood")
112
+
dbListFields(diabetes_db, "exam")
113
+
```
114
+
115
+
La table `blood` comprend une série de mesure associée à une prise de sang : Cholestérol total, taux de sucre, taux de HDL, ratio cholestérol/HDL ou encore les Hémoglobines glycolyse
116
+
117
+
La table `exam` comprend une série de mesures obtenue à la suite d'un examen clinique : âge, sexe, taille, masse, pression sanguine systolique et diastolique, tour de taille, tour de hanche
118
+
119
+
Utilisez la fonction tbl() afin de produire deux objets qui vont accepter les verbes comme filter(), select(), group_by(),... afin de réaliser un remaniement de données.
120
+
121
+
```{r tbl, exercise = TRUE}
122
+
blood_db <- ___
123
+
blood_db
124
+
exam_db <- ___
125
+
exam_db
126
+
```
127
+
128
+
```{r tbl-solution}
129
+
blood_db <- tbl(diabetes_db, "blood")
130
+
blood_db
131
+
exam_db <- tbl(diabetes_db, "exam")
132
+
exam_db
133
+
```
134
+
135
+
```{r tbl-check}
136
+
grade_code("Vous avez à présent deux objets que vous allez pouvoir manipuler simplement avec les fonctions du remaniement de données que vous maitrisez.")
137
+
```
138
+
139
+
Commençons par une instruction simple. Sélectionnez les individus de plus de 60 ans. Employez l'objet pertinent `blood_db`ou `exam_blood`.
140
+
141
+
```{r db1_h2, exercise = TRUE}
142
+
exam60 <- ___(___, ___ >= ___)
143
+
# Affichez la requête SQL réalisée
144
+
___(___)
145
+
# Collectez vos résultats
146
+
collect_dtx(___)
147
+
```
148
+
149
+
```{r db1_h2-hint-1}
150
+
exam60 <- filter(exam_db, ___>=___)
151
+
# Affichez la requête SQL realisée
152
+
___(___)
153
+
# Collectez vos résultats
154
+
collect_dtx(exam60)
155
+
156
+
#### ATTENTION: Hint suivant = solution !####
157
+
```
158
+
159
+
```{r db1_h2-solution}
160
+
exam60 <- filter(exam_db, age>=60)
161
+
# Affichez la requête SQL realisée
162
+
show_query(exam60)
163
+
# Collectez vos résultats
164
+
collect_dtx(exam60)
165
+
```
166
+
167
+
```{r db1_h2-check}
168
+
grade_code("Commencez par analyser la requête SQL obtenue avec la fonction show_query(). On observe que la fonction filter() va être convertie en requête SQL. On va réaliser une sélection (SELECT) dans (FROM) la table `exam` où (WHERE) la variable age est supérieur à 60 (`age` >= 60). La fonction collect_*() permet d'exécuter la requête et d'en récupérer le résultat.")
169
+
```
170
+
171
+
Sélectionnez les individus de plus de 25 ans et de moins de 45 ans. Gardez uniquement les variables suivantes : id, age, gender, waist, hip. Collectez le résultat de votre sélection dans la variable `exam25`. Affichez ensuite les 6 premières lignes de votre tableau collecté.
172
+
173
+
```{r db2_h2, exercise = TRUE}
174
+
___ %>.%
175
+
___(., ___ >= ___, ___ ___ ___) %>.%
176
+
___(., ___) %->%
177
+
___
178
+
# Affichage des 6 premières lignes du tableau
179
+
head(___)
180
+
```
181
+
182
+
```{r db2_h2-hint-1}
183
+
exam_db %>.%
184
+
___(., age >= 25, ___ ___ ___) %>.%
185
+
___(., id, ___) %->%
186
+
exam25
187
+
# Affichage des 6 premières lignes du tableau
188
+
head(exam25)
189
+
190
+
#### ATTENTION: Hint suivant = solution !####
191
+
```
192
+
193
+
```{r db2_h2-solution}
194
+
## Solution ##
195
+
exam_db %>.%
196
+
filter(., age >= 25, age <= 45) %>.%
197
+
select(., id, age, gender, waist, hip) %->%
198
+
exam25
199
+
# Affichage des 6 premières lignes du tableau
200
+
head(exam25)
201
+
```
202
+
203
+
```{r db2_h2-check}
204
+
grade_code("Vous pouvez observer qu'avec l'assignation alternative, une requête sur une base de données est très similaire à un remaniement sur un tableau de données classique de type data.table. On récupère directement le résultat avec %->%.")
205
+
```
206
+
207
+
Sélectionnez 25 individus aléatoires par sexe. Gardez ensuite uniquement les variables `id` et `gender`. Assignez cette requête à `exam_red`. Dans un second temps, collectez le résultat.
208
+
209
+
```{r db3_h2, exercise = TRUE}
210
+
___ %>.%
211
+
___(., ___) |> slice_sample(n = ___) %>.%
212
+
___(., ___) -> ___
213
+
# Collecte du résultat
214
+
collect_dtx(___)
215
+
```
216
+
217
+
```{r db3_h2-hint-1}
218
+
___ %>.%
219
+
group_by(., ___) |> slice_sample(n = 25) %>.%
220
+
select(., ___) -> exam_red
221
+
222
+
# Collecte du résultat
223
+
collect_dtx(___)
224
+
225
+
#### ATTENTION: Hint suivant = solution !####
226
+
```
227
+
228
+
```{r db3_h2-solution}
229
+
## Solution ##
230
+
exam_db %>.%
231
+
group_by(., gender) |> slice_sample(n = 25) %>.%
232
+
select(., id, gender) -> exam_red
233
+
# Collecte du résultat
234
+
collect_dtx(exam_red)
235
+
```
236
+
237
+
```{r db3_h2-check}
238
+
grade_code("Nous allons pouvoir employer `exam_red` qui est une suite d'instruction afin de réaliser une requête plus complexe.")
239
+
```
240
+
241
+
Employez l'objet que vous venez de créer (`exam_red`) afin d'extraite uniquement le taux de cholestérol total des personnes sélectionnées. Vous allez donc devoir réaliser une jointure (réalisez une jointure à gauche).
242
+
243
+
```{r db4_h2, exercise = TRUE}
244
+
# Jointure, sélection et collecte
245
+
cholesterol %<-% ___(exam_red, select(___, ___, ___), by = "___")
246
+
247
+
# Graphique sur les données collectées.
248
+
chart(data = cholesterol, chol ~ gender) +
249
+
geom_boxplot() +
250
+
labs(x = "Genre", y = "Cholesterol total")
251
+
```
252
+
253
+
```{r db4_h2-hint-1}
254
+
# Jointure, sélection et collecte
255
+
cholesterol %<-% left_join(exam_red, select(___, ___, ___), by = "___")
256
+
257
+
# Graphique sur les données collectées.
258
+
chart(data = cholesterol, chol ~ gender) +
259
+
geom_boxplot() +
260
+
labs(x = "Genre", y = "Cholestérol total")
261
+
```
262
+
263
+
```{r db4_h2-solution}
264
+
# Jointure, sélection et collecte
265
+
cholesterol %<-% left_join(exam_red, select(blood_db, id, chol), by = "id")
266
+
267
+
# Graphique sur les données collectées.
268
+
chart(data = cholesterol, chol ~ gender) +
269
+
geom_boxplot() +
270
+
labs(x = "Genre", y = "Cholestérol total")
271
+
```
272
+
273
+
```{r db4_h2-check}
274
+
grade_code("Vous avez employez un objet qui contenait une suite d'instruction que vous avez combiné avec une autre table à l'aide d'une jointure. Comme vous pouvez le voir, il est possible de réaliser toutes les fontions que vous avez l'habitude d'employer sur une base de données.")
275
+
```
276
+
277
+
## Conclusion
278
+
279
+
Grâce au package {dbplyr} vous avez appris à réaliser des requêtes sur des bases de données en toute simplicité. Entre une base de données et un tableau de données, ce package permet d'employer les mêmes fonctions.
280
+
281
+
Maintenant que vous avez compris la logique et que vous êtes capable d'écrire le code permettant de réaliser une requête SQL, vous pouvez appliquer cette technique par vous-même.
282
+
283
+
```{r comm_noscore, echo=FALSE}
284
+
question_text(
285
+
"Laissez-nous vos impressions sur cet outil pédagogique",
286
+
answer("", TRUE, message = "Pas de commentaires... C'est bien aussi."),
0 commit comments