From 54d5401d0e7a265043eb30a4b95623da73d033b7 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:25:43 +0100
Subject: [PATCH 01/14] identify iris dataset
---
shiny_tutorial.Rmd | 2 ++
1 file changed, 2 insertions(+)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index fdb4ff8..7dca21e 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -24,6 +24,8 @@ library(learnr)
## Introduction
+### Iris dataset
+
Pour le tutoriel, nous allons utiliser un jeu de données intégré à R, nommé Iris. Il recense les tailles de pétales et de sépales pour un ensemble d'individus "iris" de trois espèces différentes, setosa, versicolor et virginica.
Exécuter le code suivant, bouton `Run code`, pour afficher les premières lignes du jeu de données:
--
GitLab
From af979ce4ecd6ecf6f6e6d24ed08b8a57dd30f436 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:26:42 +0100
Subject: [PATCH 02/14] document how to create a shiny project from scratch in
RStudio
---
shiny_tutorial.Rmd | 22 ++++++++++++++++++++--
1 file changed, 20 insertions(+), 2 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 7dca21e..e42a480 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -34,10 +34,28 @@ Exécuter le code suivant, bouton `Run code`, pour afficher les premières ligne
head(iris)
```
+## Développer une application Shiny
-## Base d'une application Shiny
+### Créer une application Shiny
-La base de notre application Shiny de départ est comprise dans deux fichiers obligatoires au fonctionnement d'une application Shiny, `ui.R` et `server.R`.
+Créer un répertoire pour l’application avec **RStudio**.
+
+```bash
+File -> New Project -> New Directory -> Shiny Web Application
+```
+
+Choisir une application **Multiple File**.
+
+Si cette option n’est pas disponible (ça peut dépendre des versions de Rstudio), on pourra utiliser
+
+```bash
+File -> New File -> Shiny Web App -> Multiple File
+```
+
+Deux fichier sont automatiquement générés : `ui.R` et `server.R`. Lancer l’application en cliquant sur le bouton `Run App`.
+
+ * Changer le titre de l’application. On pourra l’appeler My first application.
+ * Mettre à jour et vérifier que le titre a bien été changé.
### ui.R
--
GitLab
From 95deefd6586ba17ec8b44b3802b70ea76d03c3f0 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:28:49 +0100
Subject: [PATCH 03/14] update doc and adapt code block to fit lines size
---
shiny_tutorial.Rmd | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index e42a480..e95aeb4 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -59,9 +59,9 @@ Deux fichier sont automatiquement générés : `ui.R` et `server.R`. Lancer l’
### ui.R
-Voici un exemple de `ui.R` que nous allons utiliser.
+Voici un exemple de `ui.R` que nous allons utiliser. Lancer le code avec le bouton `Run code` pour voir le rendu.
-```{r ui_R, exercise=TRUE}
+```{r ui_R, exercise=TRUE, exercise.lines=20, eval=FALSE}
# k-means only works with numerical variables,
# so don't give the user the option to select
# a categorical variable
--
GitLab
From dff97f3113b14258ddbbaa7c59f73bd38526f2f0 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:30:04 +0100
Subject: [PATCH 04/14] update selectedData exercice with hints and visual
solution
---
shiny_tutorial.Rmd | 102 ++++++++++++++++++++++++++++++++++++++-------
1 file changed, 88 insertions(+), 14 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index e95aeb4..b746faf 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -100,39 +100,113 @@ Il s'agit maintenant de remplir le fichier server.R pour obtenir des résultats
Créer une reactive avec reactive({}) pour générer un tableau dynamique récupérant les 2 colonnes correspondant aux variables X et Y sélectionnées par l’utilisateur sur les données iris et ranger ce tableau dans une variable « selectedData »
-```{r server_R_selected_data, exercise=TRUE}
-function(input, output, session) {
+```{r server_R_selected_data, exercise=TRUE, exercise.warn_invisible=TRUE}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
-}
+# }
+```
+
+```{r server_R_selected_data-hint-1}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ selectedData <- reactive({...})
+
+# }
+```
+
+```{r server_R_selected_data-hint-2}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ selectedData <- reactive({
+ iris[, ... ]
+})
+
+# }
+```
+
+```{r server_R_selected_data-hint-3}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ selectedData <- reactive({
+ iris[, c(input$xcol, input$ycol)]
+ })
+
+# }
```
```{r server_R_selected_data-solution}
-function(input, output, session) {
+# function(input, output, session) {
+# ajouter votre code ci-dessous
# Combine the selected variables into a new data frame
selectedData <- reactive({
iris[, c(input$xcol, input$ycol)]
})
-}
+
+# }
```
-### Générer le clustering k-means dasn une fonction reactive({})
+### Solution
-Créer une reactive avec reactive({}) pour générer un cluster sur le tableau dynamique précédent, utilisant la variable « Cluster count » comme nombre de clusters à créer et ranger ce résultat dans une variable « clusters ». Utiliser la fonction kmeans() pour générer ces clusters.
+Et voilà ce que contient `selectedData`:
-```{r server_R_clusters, exercise=TRUE}
-function(input, output, session) {
+```{r server_R_selected_data-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
-}
+pageWithSidebar(
+ headerPanel('Iris: select data'),
+ sidebarPanel(
+ selectInput('xcol_sd', 'X Variable', vars),
+ selectInput('ycol_sd', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_sd', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("Selected data", DT::dataTableOutput("sd_selectedData"))
+ )
+ )
+)
```
-```{r server_R_clusters-solution}
-function(input, output, session) {
-
+```{r server_R_selected_data-print, echo=TRUE, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
# Combine the selected variables into a new data frame
selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
+ iris[, c(input$xcol_sd, input$ycol_sd)]
})
+
+ output$sd_selectedData <- DT::renderDataTable(
+ DT::datatable(
+ selectedData(),
+ options = list(
+ dom = 'Bfrtip',
+ lengthMenu = list(c(5, 15, -1), c('5', '15', 'All')),
+ pageLength = 15,
+ buttons = list(
+ list(
+ extend = "collection",
+ text = 'Show All',
+ action = DT::JS("function ( e, dt, node, config ) {
+ dt.page.len(-1);
+ dt.ajax.reload();
+ }")
+ )
+ )
+ )
+ )
+ )
+
+# }
+```
clusters <- reactive({
kmeans(selectedData(), input$clusters)
--
GitLab
From e7dbd4c9abd17611660bca7a28329c4e727e60b9 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:30:42 +0100
Subject: [PATCH 05/14] update render selectedData table exercice with hints
and visual solution
---
shiny_tutorial.Rmd | 97 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 97 insertions(+)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index b746faf..1f5b1da 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -208,6 +208,103 @@ pageWithSidebar(
# }
```
+### Générer un tableau des données sélectionnées pour le graphique
+
+Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
+
+```{r server_R_render_table, exercise=TRUE, context = "server", exercise.warn_invisible=TRUE}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+# }
+```
+
+```{r server_R_render_table-hint-1}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$table <- renderTable({...})
+
+# }
+```
+
+```{r server_R_render_table-hint-2}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$table <- renderTable({
+ selectedData()
+ })
+
+# }
+```
+
+```{r server_R_render_table-solution}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$table <- renderTable({
+ selectedData()
+ })
+
+# }
+```
+
+### Solution
+
+Et voilà ce que contient `output$table`:
+
+```{r server_R_render_table-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
+
+pageWithSidebar(
+ headerPanel('Iris: print selected data table'),
+ sidebarPanel(
+ selectInput('xcol_tbl', 'X Variable', vars),
+ selectInput('ycol_tbl', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_tbl', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("Table", DT::dataTableOutput("tbl_selectedData"))
+ )
+ )
+)
+```
+
+```{r server_R_render_table-print, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ tblselectedData <- reactive({
+ iris[, c(input$xcol_tbl, input$ycol_tbl)]
+ })
+
+ output$tbl_selectedData <- DT::renderDataTable(
+ DT::datatable(
+ tblselectedData(),
+ options = list(
+ dom = 'Bfrtip',
+ lengthMenu = list(c(5, 15, -1), c('5', '15', 'All')),
+ pageLength = 15,
+ buttons = list(
+ list(
+ extend = "collection",
+ text = 'Show All',
+ action = DT::JS("function ( e, dt, node, config ) {
+ dt.page.len(-1);
+ dt.ajax.reload();
+ }")
+ )
+ )
+ )
+ )
+ )
+
+# }
+```
+
clusters <- reactive({
kmeans(selectedData(), input$clusters)
})
--
GitLab
From 2626748ff24c90fafc4361db911adb0f0486331b Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:31:22 +0100
Subject: [PATCH 06/14] update summary selectedData exercice with hints and
visual solution
---
shiny_tutorial.Rmd | 87 ++++++++++++++++++++++++----------------------
1 file changed, 45 insertions(+), 42 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 1f5b1da..2829d12 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -208,100 +208,103 @@ pageWithSidebar(
# }
```
-### Générer un tableau des données sélectionnées pour le graphique
-Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
+### Générer un résumé statistique du tableau dynamique
-```{r server_R_render_table, exercise=TRUE, context = "server", exercise.warn_invisible=TRUE}
+Générer un texte dynamique avec renderPrint({}) représentant un résumé statistique du tableau dynamique généré précédemment avec la fonction summary() et ranger le résultat dans output$summary, puis le représenter côté UI dans le tabPanel « Summary ».
+
+```{r server_R_render_print, exercise=TRUE, context = "server", exercise.warn_invisible=TRUE}
# function(input, output, session) {
# ajouter votre code ci-dessous
# }
```
-```{r server_R_render_table-hint-1}
+```{r server_R_render_print-hint-1}
# function(input, output, session) {
# ajouter votre code ci-dessous
- output$table <- renderTable({...})
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({...})
# }
```
-```{r server_R_render_table-hint-2}
+```{r server_R_render_print-hint-2}
# function(input, output, session) {
# ajouter votre code ci-dessous
- output$table <- renderTable({
- selectedData()
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(...)
})
# }
```
-```{r server_R_render_table-solution}
+```{r server_R_render_print-hint-3}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
- output$table <- renderTable({
- selectedData()
+
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(selectedData())
})
# }
```
+```{r server_R_render_print-solution}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(selectedData())
+ })
+
+# }
+```
+
### Solution
-Et voilà ce que contient `output$table`:
+Et voilà ce que contient `output$summary`:
-```{r server_R_render_table-display, echo=FALSE}
+```{r server_R_render_print-display, echo=FALSE}
vars <- setdiff(names(iris), "Species")
pageWithSidebar(
- headerPanel('Iris: print selected data table'),
+ headerPanel('Iris k-means clustering'),
sidebarPanel(
- selectInput('xcol_tbl', 'X Variable', vars),
- selectInput('ycol_tbl', 'Y Variable', vars, selected = vars[[2]]),
- numericInput('clusters_tbl', 'Cluster count', 3, min = 1, max = 9)
+ selectInput('xcol_smry', 'X Variable', vars),
+ selectInput('ycol_smry', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_smry', 'Cluster count', 3, min = 1, max = 9)
),
mainPanel(
tabsetPanel(type = "tabs",
- tabPanel("Table", DT::dataTableOutput("tbl_selectedData"))
+ tabPanel("Summary", verbatimTextOutput("print_summary"))
)
)
)
```
-```{r server_R_render_table-print, context = "server"}
+```{r server_R_render_print-print, context = "server"}
# function(input, output, session) {
# ajouter votre code ci-dessous
# Combine the selected variables into a new data frame
- tblselectedData <- reactive({
- iris[, c(input$xcol_tbl, input$ycol_tbl)]
+ smryselectedData <- reactive({
+ iris[, c(input$xcol_smry, input$ycol_smry)]
})
- output$tbl_selectedData <- DT::renderDataTable(
- DT::datatable(
- tblselectedData(),
- options = list(
- dom = 'Bfrtip',
- lengthMenu = list(c(5, 15, -1), c('5', '15', 'All')),
- pageLength = 15,
- buttons = list(
- list(
- extend = "collection",
- text = 'Show All',
- action = DT::JS("function ( e, dt, node, config ) {
- dt.page.len(-1);
- dt.ajax.reload();
- }")
- )
- )
- )
- )
- )
+ smryclusters <- reactive({
+ kmeans(smryselectedData(), input$clusters_smry)
+ })
+ output$print_summary <- renderPrint({
+ summary(smryselectedData())
+ })
+
# }
```
--
GitLab
From 6c06942ee7dd1ab4a9c4a38feeb55b94869684a7 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:32:06 +0100
Subject: [PATCH 07/14] update k-means clustering exercice with hints and
visual solution
---
shiny_tutorial.Rmd | 71 ++++++++++++++++++++--------------------------
1 file changed, 30 insertions(+), 41 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 2829d12..be32816 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -208,110 +208,99 @@ pageWithSidebar(
# }
```
+### Générer le clustering k-means dans une fonction reactive({})
-### Générer un résumé statistique du tableau dynamique
-
-Générer un texte dynamique avec renderPrint({}) représentant un résumé statistique du tableau dynamique généré précédemment avec la fonction summary() et ranger le résultat dans output$summary, puis le représenter côté UI dans le tabPanel « Summary ».
+Créer une reactive avec reactive({}) pour générer un cluster sur le tableau dynamique précédent, utilisant la variable « Cluster count » comme nombre de clusters à créer et ranger ce résultat dans une variable « clusters ». Utiliser la fonction kmeans() pour générer ces clusters.
-```{r server_R_render_print, exercise=TRUE, context = "server", exercise.warn_invisible=TRUE}
+```{r server_R_clusters, exercise=TRUE, exercise.warn_invisible=TRUE}
# function(input, output, session) {
# ajouter votre code ci-dessous
# }
```
-```{r server_R_render_print-hint-1}
+```{r server_R_clusters-hint-1}
# function(input, output, session) {
# ajouter votre code ci-dessous
- # Generate a summary of the data ----
- output$summary <- renderPrint({...})
+ clusters <- reactive({...})
# }
```
-```{r server_R_render_print-hint-2}
+```{r server_R_clusters-hint-2}
# function(input, output, session) {
# ajouter votre code ci-dessous
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(...)
+ clusters <- reactive({
+ kmeans(...)
})
# }
```
-```{r server_R_render_print-hint-3}
+```{r server_R_clusters-hint-3}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(selectedData())
+
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
})
# }
```
-```{r server_R_render_print-solution}
+```{r server_R_clusters-solution}
# function(input, output, session) {
# ajouter votre code ci-dessous
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(selectedData())
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
})
-
+
# }
```
### Solution
-Et voilà ce que contient `output$summary`:
+Et voilà ce que contient `clusters`:
-```{r server_R_render_print-display, echo=FALSE}
+```{r server_R_clusters-display, echo=FALSE}
vars <- setdiff(names(iris), "Species")
pageWithSidebar(
- headerPanel('Iris k-means clustering'),
+ headerPanel('Iris print k-means clustering results'),
sidebarPanel(
- selectInput('xcol_smry', 'X Variable', vars),
- selectInput('ycol_smry', 'Y Variable', vars, selected = vars[[2]]),
- numericInput('clusters_smry', 'Cluster count', 3, min = 1, max = 9)
+ selectInput('xcol_km', 'X Variable', vars),
+ selectInput('ycol_km', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_km', 'Cluster count', 3, min = 1, max = 9)
),
mainPanel(
tabsetPanel(type = "tabs",
- tabPanel("Summary", verbatimTextOutput("print_summary"))
+ tabPanel("K-means clusters", verbatimTextOutput("km_clusters"))
)
)
)
```
-```{r server_R_render_print-print, context = "server"}
+```{r server_R_clusters-print, context = "server"}
# function(input, output, session) {
# ajouter votre code ci-dessous
# Combine the selected variables into a new data frame
- smryselectedData <- reactive({
- iris[, c(input$xcol_smry, input$ycol_smry)]
+ kmselectedData <- reactive({
+ iris[, c(input$xcol_km, input$ycol_km)]
})
- smryclusters <- reactive({
- kmeans(smryselectedData(), input$clusters_smry)
+ kmclusters <- reactive({
+ kmeans(kmselectedData(), input$clusters_km)
})
- output$print_summary <- renderPrint({
- summary(smryselectedData())
+ output$km_clusters <- renderPrint({
+ kmclusters()
})
# }
-```
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
- })
-}
```
### Générer le plot dynamique du clustering kmeans
--
GitLab
From ab6e190e80643e5840fcf59d0f71288bbfc3426a Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:33:06 +0100
Subject: [PATCH 08/14] update plot k-means clustering exercise with hints and
visual solution
---
shiny_tutorial.Rmd | 211 +++++++++++++++++++--------------------------
1 file changed, 91 insertions(+), 120 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index be32816..e2febfe 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -208,122 +208,104 @@ pageWithSidebar(
# }
```
-### Générer le clustering k-means dans une fonction reactive({})
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
+ })
+}
+```
+
+### Générer le plot dynamique du clustering kmeans
-Créer une reactive avec reactive({}) pour générer un cluster sur le tableau dynamique précédent, utilisant la variable « Cluster count » comme nombre de clusters à créer et ranger ce résultat dans une variable « clusters ». Utiliser la fonction kmeans() pour générer ces clusters.
+Générer un graphique dynamique avec renderPlot{()} représentant le tableau dynamique avec la fonction plot() et colorer les points selon le cluster auquel ils appartiennent avec le paramètre « col ». Pour récupérer les clusters depuis la variable « clusters », utiliser clusters()\$cluster. Ranger le résultat dans output\$plot1 et le représenter côté UI dans le tabPanel « Plot ».
-```{r server_R_clusters, exercise=TRUE, exercise.warn_invisible=TRUE}
+```{r server_R_render_plot, exercise=TRUE, exercise.warn_invisible=TRUE}
# function(input, output, session) {
# ajouter votre code ci-dessous
# }
```
-```{r server_R_clusters-hint-1}
+```{r server_R_render_plot-hint-1}
# function(input, output, session) {
# ajouter votre code ci-dessous
- clusters <- reactive({...})
+ output$plot1 <- renderPlot({...})
# }
```
-```{r server_R_clusters-hint-2}
+```{r server_R_render_plot-hint-2}
# function(input, output, session) {
# ajouter votre code ci-dessous
- clusters <- reactive({
- kmeans(...)
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
})
# }
```
-```{r server_R_clusters-hint-3}
+```{r server_R_render_plot-hint-3}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
+
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
+ # define margins: replace *_margin placeholders by real values
+ par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
})
# }
```
-```{r server_R_clusters-solution}
+```{r server_R_render_plot-hint-4}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
+
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
+ # define margins: replace *_margin placeholders by real values
+ par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
+
+ # create the plot
+ plot(selectedData(),
+ ...)
+
})
# }
```
-### Solution
-
-Et voilà ce que contient `clusters`:
-
-```{r server_R_clusters-display, echo=FALSE}
-vars <- setdiff(names(iris), "Species")
-
-pageWithSidebar(
- headerPanel('Iris print k-means clustering results'),
- sidebarPanel(
- selectInput('xcol_km', 'X Variable', vars),
- selectInput('ycol_km', 'Y Variable', vars, selected = vars[[2]]),
- numericInput('clusters_km', 'Cluster count', 3, min = 1, max = 9)
- ),
- mainPanel(
- tabsetPanel(type = "tabs",
- tabPanel("K-means clusters", verbatimTextOutput("km_clusters"))
- )
- )
-)
-```
-
-```{r server_R_clusters-print, context = "server"}
+```{r server_R_render_plot-hint-5}
# function(input, output, session) {
# ajouter votre code ci-dessous
- # Combine the selected variables into a new data frame
- kmselectedData <- reactive({
- iris[, c(input$xcol_km, input$ycol_km)]
- })
-
- kmclusters <- reactive({
- kmeans(kmselectedData(), input$clusters_km)
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
+ # define margins: replace *_margin placeholders by real values
+ par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
+
+ # create the plot: set the points color, shape, etc.
+ plot(selectedData(),
+ ...)
+ # add the cluster centers: set the points color, shape, etc.
+ points(clusters()$centers, ...)
})
- output$km_clusters <- renderPrint({
- kmclusters()
- })
-
# }
```
-### Générer le plot dynamique du clustering kmeans
-
-Générer un graphique dynamique avec renderPlot{()} représentant le tableau dynamique avec la fonction plot() et colorer les points selon le cluster auquel ils appartiennent avec le paramètre « col ». Pour récupérer les clusters depuis la variable « clusters », utiliser clusters()\$cluster. Ranger le résultat dans output\$plot1 et le représenter côté UI dans le tabPanel « Plot ».
-
-```{r server_R_render_plot, exercise=TRUE}
-function(input, output, session) {
-
-}
-```
-
-```{r server_R_render_plot-solution}
-function(input, output, session) {
-
- # Combine the selected variables into a new data frame
- selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
- })
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
- })
+```{r server_R_render_plot-hint-6}
+# function(input, output, session) {
+# full solution
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
@@ -335,30 +317,13 @@ function(input, output, session) {
pch = 20, cex = 3)
points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
-}
-```
-
-### Générer un résumé statistique du tableau dynamique
-Générer un texte dynamique avec renderPrint({}) représentant un résumé statistique du tableau dynamique généré précédemment avec la fonction summary() et ranger le résultat dans output$summary, puis le représenter côté UI dans le tabPanel « Summary ».
-
-```{r server_R_render_print, exercise=TRUE}
-function(input, output, session) {
-
-}
+# }
```
-```{r server_R_render_print-solution}
-function(input, output, session) {
-
- # Combine the selected variables into a new data frame
- selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
- })
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
- })
+```{r server_R_render_plot-solution, context="server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
@@ -371,55 +336,61 @@ function(input, output, session) {
points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(selectedData())
- })
-}
+# }
```
-### Générer un tableau des données sélectionnées pour le graphique
+### Solution
-Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
+Et voilà ce que contient `output$plot1`:
-```{r server_R_render_table, exercise=TRUE}
-function(input, output, session) {
+```{r server_R_render_plot-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
-}
+pageWithSidebar(
+ headerPanel('Iris plot k-means clustering results'),
+ sidebarPanel(
+ selectInput('xcol_plot', 'X Variable', vars),
+ selectInput('ycol_plot', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_plot', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("K-means clusters plot", plotOutput("km_plot")),
+ tabPanel("K-means clusters", verbatimTextOutput("print_clusters"))
+ )
+ )
+)
```
-```{r server_R_render_table-solution}
-function(input, output, session) {
+```{r server_R_render_plot-print, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
# Combine the selected variables into a new data frame
- selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
+ plotselectedData <- reactive({
+ iris[, c(input$xcol_plot, input$ycol_plot)]
})
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
+ plotclusters <- reactive({
+ kmeans(plotselectedData(), input$clusters_plot)
})
- output$plot1 <- renderPlot({
+ output$print_clusters <- renderPrint({
+ plotclusters()
+ })
+
+ output$km_plot <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
"#FF7F00", "#FFFF33", "#A65628", "#F781BF", "#999999"))
par(mar = c(5.1, 4.1, 0, 1))
plot(selectedData(),
- col = clusters()$cluster,
+ col = plotclusters()$cluster,
pch = 20, cex = 3)
- points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
+ points(plotclusters()$centers, pch = 4, cex = 4, lwd = 4)
})
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(selectedData())
- })
-
- output$table <- renderTable({
- selectedData()
- })
-}
+# }
```
## Application Shiny complète
--
GitLab
From edb69e441d2d34ef6afcf269ce7a031660eb0e95 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:33:57 +0100
Subject: [PATCH 09/14] update ui in shiny demo live
---
shiny_tutorial.Rmd | 186 +++++++++++++++------------------------------
1 file changed, 63 insertions(+), 123 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index e2febfe..3616fa5 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -218,94 +218,23 @@ pageWithSidebar(
Générer un graphique dynamique avec renderPlot{()} représentant le tableau dynamique avec la fonction plot() et colorer les points selon le cluster auquel ils appartiennent avec le paramètre « col ». Pour récupérer les clusters depuis la variable « clusters », utiliser clusters()\$cluster. Ranger le résultat dans output\$plot1 et le représenter côté UI dans le tabPanel « Plot ».
-```{r server_R_render_plot, exercise=TRUE, exercise.warn_invisible=TRUE}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
-
-# }
-```
-
-```{r server_R_render_plot-hint-1}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
-
- output$plot1 <- renderPlot({...})
-
-# }
-```
-
-```{r server_R_render_plot-hint-2}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
-
- output$plot1 <- renderPlot({
- # create a 9 colors palette
- palette(...)
-
- })
-
-# }
-```
-
-```{r server_R_render_plot-hint-3}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
-
- output$plot1 <- renderPlot({
- # create a 9 colors palette
- palette(...)
-
- # define margins: replace *_margin placeholders by real values
- par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
- })
+```{r server_R_render_plot, exercise=TRUE}
+function(input, output, session) {
-# }
+}
```
-```{r server_R_render_plot-hint-4}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
-
- output$plot1 <- renderPlot({
- # create a 9 colors palette
- palette(...)
-
- # define margins: replace *_margin placeholders by real values
- par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
-
- # create the plot
- plot(selectedData(),
- ...)
-
+```{r server_R_render_plot-solution}
+function(input, output, session) {
+
+ # Combine the selected variables into a new data frame
+ selectedData <- reactive({
+ iris[, c(input$xcol, input$ycol)]
})
-
-# }
-```
-
-```{r server_R_render_plot-hint-5}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
-
- output$plot1 <- renderPlot({
- # create a 9 colors palette
- palette(...)
-
- # define margins: replace *_margin placeholders by real values
- par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
-
- # create the plot: set the points color, shape, etc.
- plot(selectedData(),
- ...)
- # add the cluster centers: set the points color, shape, etc.
- points(clusters()$centers, ...)
+
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
})
-
-# }
-```
-
-```{r server_R_render_plot-hint-6}
-# function(input, output, session) {
-# full solution
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
@@ -317,13 +246,30 @@ Générer un graphique dynamique avec renderPlot{()} représentant le tableau dy
pch = 20, cex = 3)
points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
+}
+```
-# }
+### Générer un résumé statistique du tableau dynamique
+
+Générer un texte dynamique avec renderPrint({}) représentant un résumé statistique du tableau dynamique généré précédemment avec la fonction summary() et ranger le résultat dans output$summary, puis le représenter côté UI dans le tabPanel « Summary ».
+
+```{r server_R_render_print, exercise=TRUE}
+function(input, output, session) {
+
+}
```
-```{r server_R_render_plot-solution, context="server"}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
+```{r server_R_render_print-solution}
+function(input, output, session) {
+
+ # Combine the selected variables into a new data frame
+ selectedData <- reactive({
+ iris[, c(input$xcol, input$ycol)]
+ })
+
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
+ })
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
@@ -336,61 +282,55 @@ Générer un graphique dynamique avec renderPlot{()} représentant le tableau dy
points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
-# }
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(selectedData())
+ })
+}
```
-### Solution
+### Générer un tableau des données sélectionnées pour le graphique
-Et voilà ce que contient `output$plot1`:
+Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
-```{r server_R_render_plot-display, echo=FALSE}
-vars <- setdiff(names(iris), "Species")
+```{r server_R_render_table, exercise=TRUE}
+function(input, output, session) {
-pageWithSidebar(
- headerPanel('Iris plot k-means clustering results'),
- sidebarPanel(
- selectInput('xcol_plot', 'X Variable', vars),
- selectInput('ycol_plot', 'Y Variable', vars, selected = vars[[2]]),
- numericInput('clusters_plot', 'Cluster count', 3, min = 1, max = 9)
- ),
- mainPanel(
- tabsetPanel(type = "tabs",
- tabPanel("K-means clusters plot", plotOutput("km_plot")),
- tabPanel("K-means clusters", verbatimTextOutput("print_clusters"))
- )
- )
-)
+}
```
-```{r server_R_render_plot-print, context = "server"}
-# function(input, output, session) {
-# ajouter votre code ci-dessous
+```{r server_R_render_table-solution}
+function(input, output, session) {
# Combine the selected variables into a new data frame
- plotselectedData <- reactive({
- iris[, c(input$xcol_plot, input$ycol_plot)]
- })
-
- plotclusters <- reactive({
- kmeans(plotselectedData(), input$clusters_plot)
+ selectedData <- reactive({
+ iris[, c(input$xcol, input$ycol)]
})
- output$print_clusters <- renderPrint({
- plotclusters()
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
})
- output$km_plot <- renderPlot({
+ output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
"#FF7F00", "#FFFF33", "#A65628", "#F781BF", "#999999"))
par(mar = c(5.1, 4.1, 0, 1))
plot(selectedData(),
- col = plotclusters()$cluster,
+ col = clusters()$cluster,
pch = 20, cex = 3)
- points(plotclusters()$centers, pch = 4, cex = 4, lwd = 4)
+ points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
-# }
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(selectedData())
+ })
+
+ output$table <- renderTable({
+ selectedData()
+ })
+}
```
## Application Shiny complète
@@ -405,7 +345,7 @@ shiny::runApp(".")
### L'application shiny en démo live
-Si vous avez exécuter la commande ``shiny::runApp(".")`` dans la console, vous pouvez voir l'application en démo live ci-dessous.
+Si vous avez exécuter la commande `shiny::runApp(".")` dans la console, vous pouvez voir l'application en démo live ci-dessous.
```{r shiny_run_app_demo, echo=FALSE}
# k-means only works with numerical variables,
@@ -422,7 +362,7 @@ pageWithSidebar(
),
mainPanel(
tabsetPanel(type = "tabs",
- tabPanel("Plot", plotOutput('plot1')),
+ tabPanel("K-means clusters plot", plotOutput('plot1')),
tabPanel("Summary", verbatimTextOutput("summary")),
tabPanel("Table", tableOutput("table"))
)
--
GitLab
From 95658d8aa1a2cc4f6b23cd70547a5bd061c7a42c Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:36:19 +0100
Subject: [PATCH 10/14] update render selectedData table exercise with hints
and visual solution
---
shiny_tutorial.Rmd | 97 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 97 insertions(+)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 3616fa5..f27dda1 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -208,6 +208,103 @@ pageWithSidebar(
# }
```
+### Générer un tableau des données sélectionnées pour le graphique
+
+Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
+
+```{r server_R_render_table, exercise=TRUE, context = "server", exercise.warn_invisible=TRUE}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+# }
+```
+
+```{r server_R_render_table-hint-1}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$table <- renderTable({...})
+
+# }
+```
+
+```{r server_R_render_table-hint-2}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$table <- renderTable({
+ selectedData()
+ })
+
+# }
+```
+
+```{r server_R_render_table-solution}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$table <- renderTable({
+ selectedData()
+ })
+
+# }
+```
+
+### Solution
+
+Et voilà ce que contient `output$table`:
+
+```{r server_R_render_table-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
+
+pageWithSidebar(
+ headerPanel('Iris: print selected data table'),
+ sidebarPanel(
+ selectInput('xcol_tbl', 'X Variable', vars),
+ selectInput('ycol_tbl', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_tbl', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("Table", DT::dataTableOutput("tbl_selectedData"))
+ )
+ )
+)
+```
+
+```{r server_R_render_table-print, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ tblselectedData <- reactive({
+ iris[, c(input$xcol_tbl, input$ycol_tbl)]
+ })
+
+ output$tbl_selectedData <- DT::renderDataTable(
+ DT::datatable(
+ tblselectedData(),
+ options = list(
+ dom = 'Bfrtip',
+ lengthMenu = list(c(5, 15, -1), c('5', '15', 'All')),
+ pageLength = 15,
+ buttons = list(
+ list(
+ extend = "collection",
+ text = 'Show All',
+ action = DT::JS("function ( e, dt, node, config ) {
+ dt.page.len(-1);
+ dt.ajax.reload();
+ }")
+ )
+ )
+ )
+ )
+ )
+
+# }
+```
+
clusters <- reactive({
kmeans(selectedData(), input$clusters)
})
--
GitLab
From 6cfa8980fc00a83709a64ada9761466c756f3f09 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:37:15 +0100
Subject: [PATCH 11/14] update summary selectedData exercise with hints and
visual solution
---
shiny_tutorial.Rmd | 99 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 99 insertions(+)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index f27dda1..7ecc6fc 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -302,6 +302,105 @@ pageWithSidebar(
)
)
+# }
+```
+
+### Générer un résumé statistique du tableau dynamique
+
+Générer un texte dynamique avec renderPrint({}) représentant un résumé statistique du tableau dynamique généré précédemment avec la fonction summary() et ranger le résultat dans output$summary, puis le représenter côté UI dans le tabPanel « Summary ».
+
+```{r server_R_render_print, exercise=TRUE, context = "server", exercise.warn_invisible=TRUE}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+# }
+```
+
+```{r server_R_render_print-hint-1}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({...})
+
+# }
+```
+
+```{r server_R_render_print-hint-2}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(...)
+ })
+
+# }
+```
+
+```{r server_R_render_print-hint-3}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(selectedData())
+ })
+
+# }
+```
+
+```{r server_R_render_print-solution}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Generate a summary of the data ----
+ output$summary <- renderPrint({
+ summary(selectedData())
+ })
+
+# }
+```
+
+### Solution
+
+Et voilà ce que contient `output$summary`:
+
+```{r server_R_render_print-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
+
+pageWithSidebar(
+ headerPanel('Iris k-means clustering'),
+ sidebarPanel(
+ selectInput('xcol_smry', 'X Variable', vars),
+ selectInput('ycol_smry', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_smry', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("Summary", verbatimTextOutput("print_summary"))
+ )
+ )
+)
+```
+
+```{r server_R_render_print-print, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ smryselectedData <- reactive({
+ iris[, c(input$xcol_smry, input$ycol_smry)]
+ })
+
+ smryclusters <- reactive({
+ kmeans(smryselectedData(), input$clusters_smry)
+ })
+
+ output$print_summary <- renderPrint({
+ summary(smryselectedData())
+ })
+
# }
```
--
GitLab
From 5b1b103b5a14a2fca2b9a6f05e9757f4f3fdcc9e Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:38:10 +0100
Subject: [PATCH 12/14] update k-means clustering exercise with hints and
visual solution
---
shiny_tutorial.Rmd | 91 +++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 90 insertions(+), 1 deletion(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 7ecc6fc..8f4e847 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -404,10 +404,99 @@ pageWithSidebar(
# }
```
+### Générer le clustering k-means dans une fonction reactive({})
+
+Créer une reactive avec reactive({}) pour générer un cluster sur le tableau dynamique précédent, utilisant la variable « Cluster count » comme nombre de clusters à créer et ranger ce résultat dans une variable « clusters ». Utiliser la fonction kmeans() pour générer ces clusters.
+
+```{r server_R_clusters, exercise=TRUE, exercise.warn_invisible=TRUE}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+# }
+```
+
+```{r server_R_clusters-hint-1}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ clusters <- reactive({...})
+
+# }
+```
+
+```{r server_R_clusters-hint-2}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ clusters <- reactive({
+ kmeans(...)
+ })
+
+# }
+```
+
+```{r server_R_clusters-hint-3}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
clusters <- reactive({
kmeans(selectedData(), input$clusters)
})
-}
+
+# }
+```
+
+```{r server_R_clusters-solution}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ clusters <- reactive({
+ kmeans(selectedData(), input$clusters)
+ })
+
+# }
+```
+
+### Solution
+
+Et voilà ce que contient `clusters`:
+
+```{r server_R_clusters-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
+
+pageWithSidebar(
+ headerPanel('Iris print k-means clustering results'),
+ sidebarPanel(
+ selectInput('xcol_km', 'X Variable', vars),
+ selectInput('ycol_km', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_km', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("K-means clusters", verbatimTextOutput("km_clusters"))
+ )
+ )
+)
+```
+
+```{r server_R_clusters-print, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ # Combine the selected variables into a new data frame
+ kmselectedData <- reactive({
+ iris[, c(input$xcol_km, input$ycol_km)]
+ })
+
+ kmclusters <- reactive({
+ kmeans(kmselectedData(), input$clusters_km)
+ })
+
+ output$km_clusters <- renderPrint({
+ kmclusters()
+ })
+
+# }
```
### Générer le plot dynamique du clustering kmeans
--
GitLab
From f5a615a5967820045826544e91e0c3b62eba2e32 Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:39:05 +0100
Subject: [PATCH 13/14] update plot k-means clustering results exercise with
hints and visual solution
---
shiny_tutorial.Rmd | 182 ++++++++++++++++++++++++++++++---------------
1 file changed, 121 insertions(+), 61 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 8f4e847..8550aa0 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -503,23 +503,94 @@ pageWithSidebar(
Générer un graphique dynamique avec renderPlot{()} représentant le tableau dynamique avec la fonction plot() et colorer les points selon le cluster auquel ils appartiennent avec le paramètre « col ». Pour récupérer les clusters depuis la variable « clusters », utiliser clusters()\$cluster. Ranger le résultat dans output\$plot1 et le représenter côté UI dans le tabPanel « Plot ».
-```{r server_R_render_plot, exercise=TRUE}
-function(input, output, session) {
+```{r server_R_render_plot, exercise=TRUE, exercise.warn_invisible=TRUE}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
-}
+# }
```
-```{r server_R_render_plot-solution}
-function(input, output, session) {
-
- # Combine the selected variables into a new data frame
- selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
+```{r server_R_render_plot-hint-1}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$plot1 <- renderPlot({...})
+
+# }
+```
+
+```{r server_R_render_plot-hint-2}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
})
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
+
+# }
+```
+
+```{r server_R_render_plot-hint-3}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
+ # define margins: replace *_margin placeholders by real values
+ par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
+ })
+
+# }
+```
+
+```{r server_R_render_plot-hint-4}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
+ # define margins: replace *_margin placeholders by real values
+ par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
+
+ # create the plot
+ plot(selectedData(),
+ ...)
+
+ })
+
+# }
+```
+
+```{r server_R_render_plot-hint-5}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
+
+ output$plot1 <- renderPlot({
+ # create a 9 colors palette
+ palette(...)
+
+ # define margins: replace *_margin placeholders by real values
+ par(mar = c(bottom_margin, left_margin, top_margin, right_margin))
+
+ # create the plot: set the points color, shape, etc.
+ plot(selectedData(),
+ ...)
+ # add the cluster centers: set the points color, shape, etc.
+ points(clusters()$centers, ...)
})
+
+# }
+```
+
+```{r server_R_render_plot-hint-6}
+# function(input, output, session) {
+# full solution
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
@@ -531,30 +602,13 @@ function(input, output, session) {
pch = 20, cex = 3)
points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
-}
-```
-
-### Générer un résumé statistique du tableau dynamique
-
-Générer un texte dynamique avec renderPrint({}) représentant un résumé statistique du tableau dynamique généré précédemment avec la fonction summary() et ranger le résultat dans output$summary, puis le représenter côté UI dans le tabPanel « Summary ».
-```{r server_R_render_print, exercise=TRUE}
-function(input, output, session) {
-
-}
+# }
```
-```{r server_R_render_print-solution}
-function(input, output, session) {
-
- # Combine the selected variables into a new data frame
- selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
- })
-
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
- })
+```{r server_R_render_plot-solution, context="server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
@@ -567,55 +621,61 @@ function(input, output, session) {
points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
})
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(selectedData())
- })
-}
+# }
```
-### Générer un tableau des données sélectionnées pour le graphique
+### Solution
-Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
+Et voilà ce que contient `output$plot1`:
-```{r server_R_render_table, exercise=TRUE}
-function(input, output, session) {
+```{r server_R_render_plot-display, echo=FALSE}
+vars <- setdiff(names(iris), "Species")
-}
+pageWithSidebar(
+ headerPanel('Iris plot k-means clustering results'),
+ sidebarPanel(
+ selectInput('xcol_plot', 'X Variable', vars),
+ selectInput('ycol_plot', 'Y Variable', vars, selected = vars[[2]]),
+ numericInput('clusters_plot', 'Cluster count', 3, min = 1, max = 9)
+ ),
+ mainPanel(
+ tabsetPanel(type = "tabs",
+ tabPanel("K-means clusters plot", plotOutput("km_plot")),
+ tabPanel("K-means clusters", verbatimTextOutput("print_clusters"))
+ )
+ )
+)
```
-```{r server_R_render_table-solution}
-function(input, output, session) {
+```{r server_R_render_plot-print, context = "server"}
+# function(input, output, session) {
+# ajouter votre code ci-dessous
# Combine the selected variables into a new data frame
- selectedData <- reactive({
- iris[, c(input$xcol, input$ycol)]
+ plotselectedData <- reactive({
+ iris[, c(input$xcol_plot, input$ycol_plot)]
})
- clusters <- reactive({
- kmeans(selectedData(), input$clusters)
+ plotclusters <- reactive({
+ kmeans(plotselectedData(), input$clusters_plot)
})
- output$plot1 <- renderPlot({
+ output$print_clusters <- renderPrint({
+ plotclusters()
+ })
+
+ output$km_plot <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
"#FF7F00", "#FFFF33", "#A65628", "#F781BF", "#999999"))
par(mar = c(5.1, 4.1, 0, 1))
plot(selectedData(),
- col = clusters()$cluster,
+ col = plotclusters()$cluster,
pch = 20, cex = 3)
- points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
+ points(plotclusters()$centers, pch = 4, cex = 4, lwd = 4)
})
- # Generate a summary of the data ----
- output$summary <- renderPrint({
- summary(selectedData())
- })
-
- output$table <- renderTable({
- selectedData()
- })
-}
+# }
```
## Application Shiny complète
--
GitLab
From 45f26ac22f6732dbfb97981ea678a276edb140cf Mon Sep 17 00:00:00 2001
From: Joseph Tran <joseph.tran@inrae.fr>
Date: Wed, 20 Mar 2024 18:39:49 +0100
Subject: [PATCH 14/14] add extra lines
---
shiny_tutorial.Rmd | 20 ++++++++++----------
1 file changed, 10 insertions(+), 10 deletions(-)
diff --git a/shiny_tutorial.Rmd b/shiny_tutorial.Rmd
index 8550aa0..bae35df 100644
--- a/shiny_tutorial.Rmd
+++ b/shiny_tutorial.Rmd
@@ -56,7 +56,7 @@ Deux fichier sont automatiquement générés : `ui.R` et `server.R`. Lancer l’
* Changer le titre de l’application. On pourra l’appeler My first application.
* Mettre à jour et vérifier que le titre a bien été changé.
-
+
### ui.R
Voici un exemple de `ui.R` que nous allons utiliser. Lancer le code avec le bouton `Run code` pour voir le rendu.
@@ -132,11 +132,11 @@ Créer une reactive avec reactive({}) pour générer un tableau dynamique récup
```{r server_R_selected_data-hint-3}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
+
# Combine the selected variables into a new data frame
selectedData <- reactive({
iris[, c(input$xcol, input$ycol)]
- })
+})
# }
```
@@ -144,7 +144,7 @@ Créer une reactive avec reactive({}) pour générer un tableau dynamique récup
```{r server_R_selected_data-solution}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
+
# Combine the selected variables into a new data frame
selectedData <- reactive({
iris[, c(input$xcol, input$ycol)]
@@ -207,7 +207,7 @@ pageWithSidebar(
# }
```
-
+
### Générer un tableau des données sélectionnées pour le graphique
Afficher le tableau dynamique avec renderTable{()} représentant le tableau utilisé pour générer le graphique et ranger le résultat dans output$table. Représenter cette table côté UI dans le tabPanel « Table ».
@@ -591,7 +591,7 @@ Générer un graphique dynamique avec renderPlot{()} représentant le tableau dy
```{r server_R_render_plot-hint-6}
# function(input, output, session) {
# full solution
-
+
output$plot1 <- renderPlot({
palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
"#FF7F00", "#FFFF33", "#A65628", "#F781BF", "#999999"))
@@ -650,16 +650,16 @@ pageWithSidebar(
```{r server_R_render_plot-print, context = "server"}
# function(input, output, session) {
# ajouter votre code ci-dessous
-
+
# Combine the selected variables into a new data frame
plotselectedData <- reactive({
iris[, c(input$xcol_plot, input$ycol_plot)]
})
-
+
plotclusters <- reactive({
kmeans(plotselectedData(), input$clusters_plot)
})
-
+
output$print_clusters <- renderPrint({
plotclusters()
})
@@ -674,7 +674,7 @@ pageWithSidebar(
pch = 20, cex = 3)
points(plotclusters()$centers, pch = 4, cex = 4, lwd = 4)
})
-
+
# }
```
--
GitLab