Giorgio Luciano

<strong>
 <strong>
  Introduction to Exploratory Data Analysis (EDA)
 </strong>
</strong>
Exploratory Data Analysis (EDA) is the crucial first step in the data analysis process. Before applying complex statistical models or machine learning algorithms, it is essential to understand the structure, trends, and peculiarities of the data you are working with.

Data Visualization

:::: {.cell}
::: {#cb1 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
library(viridis)  # Import the viridis color palette library
library(ggplot2)

set.seed(123)  # Set a seed for reproducibility
num_flips <- 50000
flips <- sample(c("Heads", "Tails"), num_flips, replace = TRUE)

# Image aspect ratio
aspect_ratio <- 1  # You can customize the aspect ratio here
n_col <- round(sqrt(num_flips) * aspect_ratio)
n_row <- ceiling(num_flips / n_col)

# Create a color matrix to represent coin flips
colors <- ifelse(flips == "Heads", "red", "blue")

# Create matrices for Heads and Tails
heads_matrix <- matrix(0, nrow = n_row, ncol = n_col)
tails_matrix <- matrix(0, nrow = n_row, ncol = n_col)

for (i in 1:num_flips) {
  if (flips[i] == "Heads") {
    heads_matrix[(i - 1) %/% n_col + 1, (i - 1) %% n_col + 1] <- 1
  } else {
    tails_matrix[(i - 1) %/% n_col + 1, (i - 1) %% n_col + 1] <- 1
  }
}

# Function to calculate the number of consecutive sequences
calculate_sequences <- function(matrix) {
  sequences <- matrix(0, nrow = nrow(matrix), ncol = ncol(matrix))
  for (i in 1:nrow(matrix)) {
    count <- 0
    for (j in 1:ncol(matrix)) {
      if (matrix[i, j] == 1) {
        count <- count + 1
        sequences[i, j] <- count
      } else {
        count <- 0
      }
    }
  }
  return(sequences)
}

# Calculate sequences for Heads and Tails matrices
sequences_heads <- calculate_sequences(heads_matrix)
sequences_tails <- calculate_sequences(tails_matrix)

# Find the longest sequence for Heads and Tails
longest_sequence_heads <- max(sequences_heads)
longest_sequence_tails <- max(sequences_tails)

# Create images with sequences and titles
par(mfrow = c(1, 2))  # Display the two images side by side
image(t(sequences_heads), col = viridis(100), main = paste("Heads Sequences (Max:", longest_sequence_heads, ")"), xaxt = "n", yaxt = "n")
image(t(sequences_tails), col = inferno(100), main = paste("Tails Sequences (Max:", longest_sequence_tails, ")"), xaxt = "n", yaxt = "n")

library(knitr)

# Calculate sequences for Heads and Tails matrices
sequences_heads <- calculate_sequences(heads_matrix)
sequences_tails <- calculate_sequences(tails_matrix)

# Calculate sequence lengths for Heads and Tails
sequence_lengths_heads <- table(sequences_heads)
sequence_lengths_tails <- table(sequences_tails)

# Calculate the percentage of sequence lengths
percentages_heads <- prop.table(sequence_lengths_heads) * 100
percentages_tails <- prop.table(sequence_lengths_tails) * 100

# Create data frames with lengths, absolute numbers, and percentages
dataframe_heads <- data.frame(
  Length = names(sequence_lengths_heads),
  Absolute_Numbers = as.numeric(sequence_lengths_heads),
  Percentage = percentages_heads
)
dataframe_tails <- data.frame(
  Length = names(sequence_lengths_tails),
  Absolute_Numbers = as.numeric(sequence_lengths_tails),
  Percentage = percentages_tails
)

# Create formatted tables
kable(dataframe_heads, caption = "Table of Heads Sequence Lengths")
kable(dataframe_tails, caption = "Table of Tails Sequence Lengths")
```
:::
::::

In this example, both module_1 and module_2 share the same IDs for input
elements (text_input and action_button). If we interact with one module,
it will affect the other module as well, leading to unexpected behavior.

:::::: {#using-namespaces-recommended .section .level2}
## Using Namespaces (Recommended) {.anchored anchor-id="using-namespaces-recommended"}

Now, let's use namespaces to create unique IDs for each module instance:

:::: {.cell}
::: {#cb2 .sourceCode .cell-code style="background: #f1f3f5;"}
``` {.sourceCode .r .code-with-copy}
library(shiny)

my_module <- function(id) {
  ns <- NS(id)
  tagList(
    textInput(inputId = ns("text_input"), label = "Enter text:"),
    actionButton(inputId = ns("action_button"), label = "Click me")
  )
}

ui <- fluidPage(
  my_module("module_1"),
  my_module("module_2")
)
```
:::
::::

In this example, we use NS to generate unique namespaces for each module
instance (module_1 and module_2). As a result, the input element IDs are
unique between instances, ensuring that interactions within one module
do not affect the other module.

::: {#conclusion .section .level3}
### Conclusion {.anchored anchor-id="conclusion"}

When creating Shiny modules, it's highly recommended to use namespaces
(NS) to prevent ID conflicts between module instances. This practice
ensures that each module operates independently and avoids unexpected
behavior when working with multiple modules in your Shiny app.
:::
::::::


library(viridis)  # Import the viridis color palette library library(ggplot2) set.seed(123)  # Set a seed for reproducibility num_flips &lt;- 50000 flips &lt;- sample(c("Heads", "Tails"), num_flips, replace = TRUE) # Image aspect ratio aspect_ratio &lt;- 1  # You can customize the aspect ratio here n_col &lt;- round(sqrt(num_flips) * aspect_ratio) n_row &lt;- ceiling(num_flips / n_col) # Create a color matrix to represent coin flips colors &lt;-

Messaggi di Rogue Scholar

Data Visualization

Namespaces in shiny: Why you need them