177 lines
6.3 KiB
Go
177 lines
6.3 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
||
// SPDX-License-Identifier: MIT
|
||
|
||
package stats
|
||
|
||
import (
|
||
"math"
|
||
"math/big"
|
||
"testing"
|
||
)
|
||
|
||
// The expectation step's posterior normalisation against an exact
|
||
// referent. The fit computes each row's responsibilities from the log
|
||
// densities and their row maximum; the quotients it publishes must
|
||
// match the posteriories a 256-bit evaluation of the same numbers
|
||
// produces, and match them at least as closely as the form that
|
||
// re-exponentiates through the row normaliser. The log densities here
|
||
// come from a closed-form bivariate evaluator, never from the mixture
|
||
// code, so the referent shares no arithmetic with the implementation.
|
||
|
||
// bigLn2 is the natural logarithm of two to a hundred places, the
|
||
// reduction constant of the reference exponential. The head the series
|
||
// accuracy needs is far shorter than the tail quoted.
|
||
const bigLn2 = "0.6931471805599453094172321214581765680755001343602552541206800094933936219696947156058633269964186875"
|
||
|
||
// referenceExp evaluates eˣ at prec mantissa bits: the argument folds
|
||
// to x = k·ln 2 + r with |r| ≤ ln 2, the series Σ rⁿ/n! converges on
|
||
// that range in under a hundred terms, and the shift multiplies by 2^k.
|
||
func referenceExp(x float64, prec uint) *big.Float {
|
||
p := prec + 64
|
||
ln2, ok := new(big.Float).SetPrec(p).SetString(bigLn2)
|
||
if !ok {
|
||
panic("referenceExp: the reduction constant failed to parse")
|
||
}
|
||
xf := new(big.Float).SetPrec(p).SetFloat64(x)
|
||
k := int(math.Round(x / math.Ln2))
|
||
r := new(big.Float).SetPrec(p).Mul(ln2, new(big.Float).SetPrec(p).SetInt64(int64(k)))
|
||
r.Sub(xf, r)
|
||
sum := new(big.Float).SetPrec(p).SetInt64(1)
|
||
term := new(big.Float).SetPrec(p).SetInt64(1)
|
||
for n := 1; n < 1000; n++ {
|
||
term.Mul(term, r)
|
||
term.Quo(term, new(big.Float).SetPrec(p).SetUint64(uint64(n)))
|
||
sum.Add(sum, term)
|
||
if e := term.MantExp(nil); term.Sign() == 0 || e < -int(p)-4 {
|
||
pow2 := new(big.Float).SetPrec(p)
|
||
pow2.SetMantExp(new(big.Float).SetPrec(p).SetInt64(1), k)
|
||
return sum.Mul(sum, pow2)
|
||
}
|
||
}
|
||
panic("referenceExp: the series failed to converge")
|
||
}
|
||
|
||
// bivariateLogDensity evaluates the normal log density through the
|
||
// closed-form inverse and determinant of the 2×2 covariance, the
|
||
// evaluator that shares nothing with the fit's forward solve.
|
||
func bivariateLogDensity(x, y float64, mean [2]float64, cov [4]float64, weight float64) float64 {
|
||
det := cov[0]*cov[3] - cov[1]*cov[2]
|
||
dx, dy := x-mean[0], y-mean[1]
|
||
inv00, inv01, inv11 := cov[3]/det, -cov[1]/det, cov[0]/det
|
||
quad := dx*dx*inv00 + 2*dx*dy*inv01 + dy*dy*inv11
|
||
return math.Log(weight) - 0.5*(2*math.Log(2*math.Pi)+math.Log(det)) - 0.5*quad
|
||
}
|
||
|
||
func TestGaussianMixturePosteriorReferenceForms(t *testing.T) {
|
||
// The reference exponential agrees with the hardware one wherever
|
||
// the hardware answer is representable: this pins the reduction
|
||
// constant and the series against an independent evaluator before
|
||
// anything else is claimed on top of them.
|
||
for _, x := range []float64{-50, -7.3, -1, -0.01, 0, 0.5, 3.7, 40} {
|
||
want := math.Exp(x)
|
||
got, _ := referenceExp(x, 256).Float64()
|
||
if math.Abs(got-want) > 1e-13*math.Max(1, math.Abs(want)) {
|
||
t.Fatalf("referenceExp(%g) = %g, math.Exp gives %g", x, got, want)
|
||
}
|
||
}
|
||
|
||
weights := []float64{0.5, 0.3, 0.2}
|
||
means := [][2]float64{{-2, 0}, {1, 1}, {3, -1}}
|
||
covs := [][4]float64{
|
||
{1, 0.3, 0.3, 0.8},
|
||
{0.5, 0, 0, 1.2},
|
||
{2, -0.5, -0.5, 0.7},
|
||
}
|
||
points := [][2]float64{
|
||
{-2.1, 0.05}, // near the first component
|
||
{0.9, 1.2}, // near the second
|
||
{3.2, -0.8}, // near the third
|
||
{0.2, 0.4}, // between the first two
|
||
{-1, 0.8}, // a broad mixture row
|
||
{5.5, -2.5}, // moderately outside every component
|
||
{-6.5, 2.5}, // the same, opposite side
|
||
{18, 24}, // far tail: every density microscopic
|
||
}
|
||
const k = 3
|
||
|
||
worstNew, worstOld := 0.0, 0.0
|
||
for _, pt := range points {
|
||
// The log densities the step would see, from the independent
|
||
// closed form.
|
||
lps := make([]float64, k)
|
||
for c := range k {
|
||
lps[c] = bivariateLogDensity(pt[0], pt[1], means[c], covs[c], weights[c])
|
||
}
|
||
rowMax := math.Inf(-1)
|
||
for _, lp := range lps {
|
||
if lp > rowMax {
|
||
rowMax = lp
|
||
}
|
||
}
|
||
// The exact posteriories of these very numbers: exponentials
|
||
// and one quotient, all at 256 bits.
|
||
exacts := make([]*big.Float, k)
|
||
exactResp := make([]float64, k)
|
||
totalExact := new(big.Float).SetPrec(256)
|
||
for c := range lps {
|
||
exacts[c] = referenceExp(lps[c], 256)
|
||
totalExact.Add(totalExact, exacts[c])
|
||
}
|
||
for c := range lps {
|
||
exactResp[c], _ = new(big.Float).SetPrec(256).Quo(exacts[c], totalExact).Float64()
|
||
}
|
||
// The published forms on the same numbers: the quotient of the
|
||
// stored exponentials, and the retired form that re-exponentiates
|
||
// through the row normaliser.
|
||
expSum := 0.0
|
||
expVals := make([]float64, k)
|
||
for c := range lps {
|
||
expVals[c] = math.Exp(lps[c] - rowMax)
|
||
expSum += expVals[c]
|
||
}
|
||
logNorm := rowMax + math.Log(expSum)
|
||
// The far tail underflows every form to zero or near it, where
|
||
// a relative comparison carries no information; the row still
|
||
// participates through the sum-to-one pin.
|
||
live := false
|
||
for c := range lps {
|
||
if exactResp[c] > 1e-200 {
|
||
live = true
|
||
}
|
||
}
|
||
rowNew, rowOld := 0.0, 0.0
|
||
sum := 0.0
|
||
for c := range lps {
|
||
newResp := expVals[c] / expSum
|
||
oldResp := math.Exp(lps[c] - logNorm)
|
||
sum += newResp
|
||
if !live {
|
||
continue
|
||
}
|
||
exact := exactResp[c]
|
||
if exact <= 1e-200 {
|
||
continue
|
||
}
|
||
en := math.Abs(newResp-exact) / exact
|
||
eo := math.Abs(oldResp-exact) / exact
|
||
rowNew = math.Max(rowNew, en)
|
||
rowOld = math.Max(rowOld, eo)
|
||
}
|
||
worstNew = math.Max(worstNew, rowNew)
|
||
worstOld = math.Max(worstOld, rowOld)
|
||
if live && math.Abs(sum-1) > 1e-14 {
|
||
t.Fatalf("point %v: the quotients sum to %.17g, want 1", pt, sum)
|
||
}
|
||
if live && rowNew > 1e-12 {
|
||
t.Fatalf("point %v: the quotient form's worst relative error is %g, want under 1e-12", pt, rowNew)
|
||
}
|
||
if live && rowOld > 1e-12 {
|
||
t.Fatalf("point %v: the re-exponentiated form's worst relative error is %g, want under 1e-12", pt, rowOld)
|
||
}
|
||
}
|
||
if worstNew > worstOld {
|
||
t.Fatalf("the quotient form is the less accurate one at the fixture: worst relative error %g against the re-exponentiated form's %g", worstNew, worstOld)
|
||
}
|
||
t.Logf("worst relative error against the 256-bit referent: quotient form %g, re-exponentiated form %g", worstNew, worstOld)
|
||
}
|