R Academy · Lekcja

Generowanie rozkładów losowych

Losuj próbki z rozkładów normalnego, jednostajnego, dwumianowego i Poissona.

Generowanie rozkładów losowych to bezpłatna lekcja R Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Funkcje rozkładów w R

R udostępnia cztery funkcje dla każdego rozkładu: r (losowanie), d (gęstość), p (prawdopodobieństwo skumulowane), q (kwantyl). Funkcje r* generują próbki losowe.

# Pattern: r<dist>(n, param1, param2, ...)
# d<dist>(x, ...) -> density/probability
# p<dist>(q, ...) -> cumulative probability
# q<dist>(p, ...) -> quantile

# Example with normal distribution:
rnorm(5, mean = 0, sd = 1)    # 5 random draws
dnorm(0, mean = 0, sd = 1)    # density at x=0
pnorm(1.96, mean = 0, sd = 1) # P(X <= 1.96)
qnorm(0.975, mean = 0, sd = 1) # z-score for 97.5%
cat('Four functions: r, d, p, q for each distribution')

rnorm(): rozkład normalny

rnorm(n, mean, sd) generuje n próbek z rozkładu N(mean, sd²). Wartością domyślną jest standardowy rozkład normalny N(0,1). Rozkład normalny jest podstawowym narzędziem statystyki — centralne twierdzenie graniczne wyjaśnia jego powszechne występowanie.

set.seed(42)
# Standard normal (mean=0, sd=1)
z_scores <- rnorm(1000)
mean(z_scores)  # ~0
sd(z_scores)    # ~1

# Custom normal (IQ scores: mean=100, sd=15)
set.seed(42)
iq_scores <- rnorm(100, mean = 100, sd = 15)
mean(iq_scores)  # ~100
sd(iq_scores)    # ~15
summary(iq_scores)

# About 68% within 1 sd
mean(abs(iq_scores - 100) < 15)  # ~0.68

runif(): rozkład jednostajny

runif(n, min, max) generuje n próbek o rozkładzie jednostajnym między min a max. Wszystkie wartości z tego zakresu są jednakowo prawdopodobne. Domyślnie: runif(n) zwraca wartości z przedziału [0, 1].

set.seed(7)
# Default: uniform on [0, 1]
u <- runif(5)
print(u)  # values in (0, 1)

# Uniform on [a, b]
temps <- runif(100, min = -10, max = 40)  # temperatures
mean(temps)   # ~15 (midpoint)
range(temps)  # should be within [-10, 40]

# Discrete simulation using floor()
dice_rolls <- floor(runif(10, min = 1, max = 7))
print(dice_rolls)  # integers 1-6
table(floor(runif(600, 1, 7)))  # roughly equal counts

rbinom(): rozkład dwumianowy

rbinom(n, size, prob) symuluje n doświadczeń dwumianowych, z których każde składa się z size prób Bernoulliego o prawdopodobieństwie sukcesu prob. Wartości size=1 należy używać do losowania z rozkładu Bernoulliego.

set.seed(123)
# 10 coin flips (prob=0.5), repeated 5 times
coin_flips <- rbinom(5, size = 10, prob = 0.5)
print(coin_flips)  # number of heads each time

# Bernoulli: single flip (size=1)
flips <- rbinom(20, size = 1, prob = 0.5)
print(flips)  # 0s and 1s
mean(flips)   # ~0.5

# Biased coin (prob=0.7)
biased <- rbinom(1000, size = 1, prob = 0.7)
mean(biased)  # ~0.7

# Many trials: normal approximation kicks in
hundred_flips <- rbinom(1000, size = 100, prob = 0.5)
mean(hundred_flips)  # ~50

rpois(): rozkład Poissona

rpois(n, lambda) generuje n próbek z rozkładu Poissona o intensywności λ. Służy on do modelowania danych zliczeniowych (liczby zdarzeń w przedziale): wizyt na stronie w ciągu minuty, defektów na jednostkę lub połączeń w ciągu godziny.

set.seed(5)
# Calls received per hour (average 3)
calls <- rpois(24, lambda = 3)  # 24 hours
print(calls)  # integers, mostly 1-6
mean(calls)   # ~3 (expectation = lambda)
var(calls)    # ~3 (variance = lambda for Poisson)

# Count the distribution
table(calls)

# Rare events (lambda=0.5)
rare_events <- rpois(100, lambda = 0.5)
table(rare_events)  # mostly 0s and 1s
mean(rare_events)   # ~0.5

rexp(): rozkład wykładniczy

rexp(n, rate) generuje n próbek z rozkładu wykładniczego o określonej intensywności. Służy on do modelowania czasu między zdarzeniami (czasów między kolejnymi zdarzeniami). Średnia = 1/rate. Ma własność bezpamięciowości.

set.seed(42)
# Time between customer arrivals (rate=2 per minute)
# Mean wait time = 1/2 = 0.5 minutes
arrival_times <- rexp(100, rate = 2)
mean(arrival_times)  # ~0.5
sd(arrival_times)    # ~0.5 (mean = sd for exponential)

# Simulate a queue
cumulative_arrivals <- cumsum(rexp(10, rate = 3))
print(round(cumulative_arrivals, 3))

# Exponential CDF: P(X <= x) = 1 - exp(-rate*x)
pexp(0.5, rate = 2)   # P(wait <= 0.5 min)
mean(arrival_times <= 0.5)  # empirical estimate

sample(): próbkowanie dyskretne

sample(x, size, replace) losuje size elementów z wektora x. replace=FALSE (domyślnie) oznacza losowanie bez zwracania; replace=TRUE pozwala na wielokrotne wylosowanie tych samych wartości.

set.seed(10)
# Sample without replacement (like drawing cards)
cards <- 1:52
hand <- sample(cards, size = 5, replace = FALSE)
print(hand)  # 5 unique cards

# Sample with replacement (bootstrap)
x <- c(10, 20, 30, 40, 50)
bootstrap_sample <- sample(x, size = 5, replace = TRUE)
print(bootstrap_sample)  # may have repeats

# Simulate rolling two dice 1000 times
dice <- function() sum(sample(1:6, 2, replace = TRUE))
rolls <- replicate(1000, dice())
table(rolls) / 1000  # empirical probabilities

Próbkowanie ważone

sample(x, size, replace, prob) używa wag prawdopodobieństwa. Wektor prob przypisuje względne prawdopodobieństwa poszczególnym elementom — jest przydatny dla niejednostajnych rozkładów dyskretnych.

set.seed(99)
# Loaded die: 6 is twice as likely
faces <- 1:6
weights <- c(1, 1, 1, 1, 1, 2)  # relative
norm_weights <- weights / sum(weights)

rolls <- sample(faces, size = 1000, replace = TRUE,
                prob = norm_weights)
table(rolls) / 1000
# 6 appears ~2/7 ~= 0.286 of the time

# Categorical sampling
categories <- c('A', 'B', 'C')
probs <- c(0.5, 0.3, 0.2)
sample(categories, 10, replace = TRUE, prob = probs)

rgeom() i rnbinom(): rozkłady zliczeniowe

rgeom(n, prob) zlicza porażki przed pierwszym sukcesem. rnbinom(n, size, prob) zlicza porażki przed osiągnięciem size sukcesów. Oba rozkłady służą do modelowania nadmiernie rozproszonych danych zliczeniowych (o większej wariancji niż rozkład Poissona).

set.seed(42)
# Geometric: flips until first head (prob=0.3)
# Number of FAILURES before first success
flips_until_head <- rgeom(10, prob = 0.3) + 1  # +1 for the success
print(flips_until_head)
mean(flips_until_head)  # ~1/0.3 = 3.33

# Negative binomial: overdispersed count data
# e.g., number of parasites per host
counts <- rnbinom(100, size = 2, prob = 0.4)
mean(counts)   # ~3 (theoretical: size*(1-p)/p)
var(counts)    # much larger than mean -> overdispersed

# Compare variance to Poisson with same mean
pois_counts <- rpois(100, lambda = mean(counts))
var(counts) / var(pois_counts)  # > 1

rt() i rf(): rozkłady t i F

rt(n, df) generuje próbki z rozkładu t o df stopniach swobody. Gdy df → ∞, rozkład ten zbiega do rozkładu normalnego. rf(n, df1, df2) generuje próbki z rozkładu F — będącego ilorazem zmiennych o rozkładzie chi-kwadrat.

set.seed(1)
# t distribution: heavier tails than normal
t_vals <- rt(1000, df = 5)
mean(t_vals)  # ~0
sd(t_vals)    # > 1 (inflated by heavy tails)

# Compare to normal
n_vals <- rnorm(1000)
# t has more extreme values (heavy tails)
sum(abs(t_vals) > 3)   # e.g., ~30
sum(abs(n_vals) > 3)   # e.g., ~3

# F distribution: used in ANOVA F-tests
f_vals <- rf(1000, df1 = 5, df2 = 20)
range(f_vals)   # always positive
mean(f_vals)    # ~df2/(df2-2) = 20/18 = 1.11

Wizualizacja rozkładów losowych

Histogramy i wykresy gęstości przedstawiają kształt symulowanych rozkładów. Empiryczną gęstość można porównać z teoretycznymi krzywymi gęstości, używając hist() z nałożonym wykresem curve(dnorm(...)).

set.seed(42)
x <- rnorm(10000, mean = 5, sd = 2)

# Quick summary statistics
summary(x)
cat('Mean:', mean(x), '\n')
cat('SD:', sd(x), '\n')
cat('Skewness (should be ~0 for normal):',
    mean(((x - mean(x))/sd(x))^3), '\n')

# Empirical quantiles vs theoretical
quantile(x, c(0.025, 0.25, 0.5, 0.75, 0.975))
# Compare to theoretical:
qnorm(c(0.025, 0.25, 0.5, 0.75, 0.975),
      mean = 5, sd = 2)

Szybki test

Sprawdź swoją wiedzę na temat funkcji R służących do generowania próbek z rozkładów losowych.

Podsumowanie: rozkłady losowe

Najważniejsze informacje: rnorm(n, mean, sd) służy do rozkładu normalnego; runif(n, min, max) do jednostajnego; rbinom(n, size, prob) do dwumianowego; rpois(n, lambda) do zliczeń Poissona; rexp(n, rate) do wykładniczych czasów oczekiwania; sample(x, size, replace) do próbkowania dyskretnego. W powtarzalnych analizach zawsze należy używać set.seed() przed generowaniem liczb losowych.

set.seed(42)
# Quick reference of common distributions:
rnorm(3, mean = 0, sd = 1)        # Normal
runif(3, min = 0, max = 1)        # Uniform
rbinom(3, size = 10, prob = 0.5)  # Binomial
rpois(3, lambda = 3)              # Poisson
rexp(3, rate = 1)                 # Exponential
rt(3, df = 10)                    # Student t
rf(3, df1 = 5, df2 = 20)          # F distribution
rgeom(3, prob = 0.3)              # Geometric
sample(1:10, 3, replace = TRUE)   # Discrete uniform
cat('R has 20+ built-in distributions')

Często zadawane pytania

Czy lekcja „Generowanie rozkładów losowych” jest bezpłatna?

Tak — pełny tekst „Generowanie rozkładów losowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Generowanie rozkładów losowych”?

Losuj próbki z rozkładów normalnego, jednostajnego, dwumianowego i Poissona. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Generowanie rozkładów losowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do R Academy