Verteilung auswählen

Kotlin Notebook

Probieren Sie diesen Leitfaden als Kotlin Notebook mit Kandy-Visualisierungen aus — führen Sie die Zellen aus, um Diagramme zu sehen und die Daten interaktiv zu erkunden.

Jede Verteilung kodiert Annahmen darüber, welche Werte möglich sind und wie wahrscheinlich sie auftreten. Dieser Leitfaden gruppiert Verteilungen nach der Art der modellierten Daten und zeigt, wie Sie die Anpassungsgüte überprüfen.

Entscheidungstabelle

Datentyp	Beispieldomäne	Verteilung	Konstruktor
Symmetrische Messungen um einen Mittelwert	Sitzungsdauer von Nutzern	`NormalDistribution`	`NormalDistribution(mu, sigma)`
Schwerere Ränder als Normal, kleine Stichproben	Geschätzte Mittelwerte mit wenigen Beobachtungen	`StudentTDistribution`	`StudentTDistribution(degreesOfFreedom)`
Positive Wartezeiten oder Dauern	Zeit zwischen Server-Fehlern	`ExponentialDistribution`	`ExponentialDistribution(rate)`
Positive Dauern mit Verschleißmuster	Lebensdauer von Hardware-Komponenten	`WeibullDistribution`	`WeibullDistribution(shape, scale)`
Rechtsschief verteilte positive Werte	API-Antwortzeiten	`LogNormalDistribution`	`LogNormalDistribution(mu, sigma)`
Anteile oder Raten in [0, 1]	Klickrate	`BetaDistribution`	`BetaDistribution(alpha, beta)`
Ereigniszählungen pro Intervall	Fehler pro Stunde	`PoissonDistribution`	`PoissonDistribution(rate)`
Erfolge bei fester Anzahl von Versuchen	Konversionen aus Seitenaufrufen	`BinomialDistribution`	`BinomialDistribution(trials, probability)`
Überdispergierte Zählungen	Support-Tickets pro Tag	`NegativeBinomialDistribution`	`NegativeBinomialDistribution(successes, probability)`
Starker rechter Rand bei positiven Daten	Einkommensverteilung, Dateigrößen	`ParetoDistribution`	`ParetoDistribution(shape, scale)`

Dauern und Wartezeiten

Antwortzeiten
Zeit zwischen Ereignissen
Komponentenlebensdauer

// API response times — often right-skewed with a long tail
val responseTime = LogNormalDistribution(mu = 4.5, sigma = 0.8)

responseTime.mean              // expected average in ms
responseTime.quantile(0.95)    // P95 latency
responseTime.quantile(0.99)    // P99 latency
responseTime.cdf(200.0)        // probability of responding under 200ms

// Time between server errors — memoryless waiting process
val timeBetweenErrors = ExponentialDistribution(rate = 0.5)

timeBetweenErrors.mean          // average time between errors
timeBetweenErrors.sf(10.0)      // probability of waiting longer than 10 units
timeBetweenErrors.quantile(0.5) // median waiting time

// Hardware component lifetime — models wear-out (shape > 1) or burn-in (shape < 1)
val componentLifetime = WeibullDistribution(shape = 2.0, scale = 5000.0)

componentLifetime.quantile(0.1)  // 10% of components fail before this time
componentLifetime.cdf(3000.0)    // probability of failure before 3000 hours
componentLifetime.sf(4000.0)     // probability of surviving past 4000 hours

Zählungen und Ereignisse

Ereigniszählungen
Feste Versuchsanzahl
Überdispergierte Zählungen

// Errors per hour on a production server
val errorsPerHour = PoissonDistribution(rate = 3.2)

errorsPerHour.pmf(0)            // probability of zero errors
errorsPerHour.cdf(5)            // probability of at most 5 errors
errorsPerHour.quantileInt(0.99) // error count exceeded only 1% of the time

// Conversions out of 1000 page views with 3.5% conversion rate
val conversions = BinomialDistribution(trials = 1000, probability = 0.035)

conversions.mean    // expected number of conversions
conversions.pmf(40) // probability of exactly 40 conversions
conversions.sf(50)  // probability of more than 50 conversions

// Support tickets until 5th resolution (variance > mean)
val tickets = NegativeBinomialDistribution(successes = 5, probability = 0.1)

tickets.mean     // expected ticket count
tickets.variance // larger than mean — overdispersion

Anteile und Raten

// Click-through rate estimated from 120 clicks in 4000 impressions
val ctr = BetaDistribution(alpha = 120.0, beta = 3880.0)

ctr.mean            // point estimate of CTR
ctr.quantile(0.025) // lower bound of 95% credible interval
ctr.quantile(0.975) // upper bound
ctr.cdf(0.035)      // probability that true CTR is below 3.5%

Allgemeine symmetrische Verteilungen

// User session duration in minutes (roughly symmetric)
val sessionDuration = NormalDistribution(mu = 12.5, sigma = 3.2)

sessionDuration.cdf(15.0)      // probability of session under 15 min
sessionDuration.quantile(0.95) // 95th percentile

// Small-sample estimate — heavier tails give more conservative intervals
val smallSampleEstimate = StudentTDistribution(degreesOfFreedom = 8.0)
smallSampleEstimate.quantile(0.975) // critical value for 95% CI

Anpassungsgüte überprüfen

Vergleichen Sie nach der Wahl einer Verteilung diese mit den beobachteten Daten mithilfe des Kolmogorov-Smirnov-Tests.

val processingTimesMs = doubleArrayOf(
    45.2, 51.8, 48.1, 52.3, 47.6, 49.9, 53.1, 46.5, 50.7, 48.8,
    51.2, 47.3, 49.1, 52.8, 46.9, 50.3, 48.5, 51.6, 47.8, 49.4
)

// Fit a Normal from sample statistics
val fitted = NormalDistribution(
    mu = processingTimesMs.mean(),
    sigma = processingTimesMs.standardDeviation()
)

val ks = kolmogorovSmirnovTest(processingTimesMs, fitted)
ks.statistic // KS statistic — smaller means better fit
ks.pValue    // high p-value means data does not contradict the distribution

Ein nicht-signifikanter KS-Test beweist nicht, dass die Verteilung korrekt ist — er bedeutet lediglich, dass die Daten dieser Wahl nicht stark widersprechen.

How-To Guides

Tutorials

Verteilung auswählen

Kotlin Notebook

Entscheidungstabelle

Dauern und Wartezeiten

Zählungen und Ereignisse

Anteile und Raten

Allgemeine symmetrische Verteilungen

Anpassungsgüte überprüfen

Kotlin Notebook

​Entscheidungstabelle

​Dauern und Wartezeiten

​Zählungen und Ereignisse

​Anteile und Raten

​Allgemeine symmetrische Verteilungen

​Anpassungsgüte überprüfen

Entscheidungstabelle

Dauern und Wartezeiten

Zählungen und Ereignisse

Anteile und Raten

Allgemeine symmetrische Verteilungen

Anpassungsgüte überprüfen