How to Select Random Samples in R

Random sampling is a cornerstone technique in statistics, machine learning, and data science. Whether you’re conducting experiments, bootstrapping data, or building predictive models, it’s crucial to know how to perform random sampling effectively. R offers a plethora of functions and techniques for random sampling, and this article will serve as a comprehensive guide for those looking to master this fundamental skill.

Importance of Random Sampling

Before we delve into the nitty-gritty, it’s worth noting why random sampling is so vital:

• Reduced Computational Load: When working with large datasets, using a random sample for preliminary analyses can save computational resources and time.
• External Validity: A random sample can help generalize findings to an entire population.
• Reduced Bias: Proper random sampling techniques can mitigate the effects of sampling bias.

Basic Techniques for Random Sampling

The sample( ) Function

The most straightforward function for random sampling in R is sample(). The function takes a vector as input and returns a random sample.

Basic Usage

# A vector of numbers from 1 to 10
data_vector <- 1:10

# Selecting 5 random numbers
random_sample <- sample(data_vector, 5)

# Output
print(random_sample)

With or Without Replacement

By default, the sample() function samples without replacement, meaning each element can be chosen only once. You can change this by setting the replace argument to TRUE.

# Sampling with replacement
random_sample <- sample(data_vector, 5, replace = TRUE)

The runif( ) Function for Continuous Data

If you’re working with continuous data, the runif() function generates uniformly distributed random numbers between a specified range.

# Generate 5 random numbers between 0 and 1
random_numbers <- runif(5, min = 0, max = 1)

Sampling from Data Frames

Using sample_n( ) from dplyr

The dplyr package offers a function called sample_n() which lets you sample a specific number of rows randomly from a data frame.

library(dplyr)

data_frame <- data.frame(id = 1:10, value = rnorm(10))

# Sampling 3 rows
sampled_data <- sample_n(data_frame, 3)

Using sample_frac( ) for Fractional Sampling

If instead of a specific number, you want to sample a fraction of your data frame, sample_frac() from dplyr comes handy.

# Sampling 20% of the data
sampled_data <- sample_frac(data_frame, 0.2)

Stratified Sampling

Sometimes, you may want to ensure that the random sample you generate is representative across certain groups or ‘strata’ within your data. The strata function in the sampling package can help.

library(sampling)

# Create a data frame with a categorical variable
data_frame <- data.frame(
  id = 1:100,
  value = rnorm(100),
  category = sample(c("A", "B", "C"), 100, replace = TRUE)
)

# Stratified sampling
strata_output <- strata(
  data_frame, 
  stratanames = c("category"), 
  size = c(5, 5, 5), 
  method = "srswor"
)

# The actual sample
sampled_data <- getdata(data_frame, strata_output)

Bootstrapping

Bootstrapping is another popular technique for random sampling, particularly useful for estimating the distribution of a statistic. R doesn’t have a native bootstrap function, but you can easily roll your own.

# Simple bootstrap function for calculating mean
bootstrap_mean <- function(data, n) {
  sample_means <- numeric(n)
  for (i in 1:n) {
    boot_sample <- sample(data, length(data), replace = TRUE)
    sample_means[i] <- mean(boot_sample)
  }
  return(sample_means)
}

# Using the bootstrap function
data_vector <- rnorm(100)
bootstrap_means <- bootstrap_mean(data_vector, 1000)

Random Sampling in Time Series

When dealing with time series data, it’s important to maintain temporal order. One way is to divide the time series into non-overlapping windows and randomly pick samples from each.

# Generate a time series data
time_series_data <- rnorm(100)

# Define window size
window_size <- 10

# Number of windows
n_windows <- length(time_series_data) / window_size

# Initialize an empty vector to hold the sample
random_sample <- numeric(n_windows)

# Sampling
for (i in seq_len(n_windows)) {
  start_index <- (i - 1) * window_size + 1
  end_index <- i * window_size
  window_data <- time_series_data[start_index:end_index]
  random_sample[i] <- sample(window_data, 1)
}

Conclusion

Random sampling is an essential technique in data manipulation and statistical analysis. The R language offers a variety of functions and packages that make random sampling both efficient and easy to perform. Whether you’re a beginner or a seasoned pro, understanding random sampling in R is a must-have skill. This guide aims to be your one-stop resource for mastering random sampling in R, equipping you with the practical skills you need for real-world data analysis.