1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
package glm
import (
"fmt"
"math"
)
// VarianceType is used to specify a GLM variance function.
type VarianceType uint8
// BinomialVar, ... define variance functions for a GLM.
const (
BinomialVar VarianceType = iota
IdentityVar
ConstantVar
SquaredVar
CubedVar
)
// NewVariance returns a new variance function object corresponding to
// the given name. Supported names are binomial, const, cubed,
// identity, and, squared.
func NewVariance(vartype VarianceType) *Variance {
switch vartype {
case BinomialVar:
return &binomVariance
case IdentityVar:
return &identVariance
case ConstantVar:
return &constVariance
case SquaredVar:
return &squaredVariance
case CubedVar:
return &cubedVariance
default:
msg := fmt.Sprintf("Unknown variance function: %d\n", vartype)
panic(msg)
}
}
// Variance represents a GLM variance function.
type Variance struct {
Name string
Var VecFunc
Deriv VecFunc
}
var binomVariance = Variance{
Name: "Binomial",
Var: binomVar,
Deriv: binomVarDeriv,
}
var identVariance = Variance{
Name: "Identity",
Var: identVar,
Deriv: identVarDeriv,
}
var constVariance = Variance{
Name: "Constant",
Var: constVar,
Deriv: constVarDeriv,
}
var squaredVariance = Variance{
Name: "Squared",
Var: squaredVar,
Deriv: squaredVarDeriv,
}
var cubedVariance = Variance{
Name: "Cubed",
Var: cubedVar,
Deriv: cubedVarDeriv,
}
func binomVar(mn []float64, v []float64) {
for i, p := range mn {
v[i] = p * (1 - p)
}
}
func binomVarDeriv(mn []float64, dv []float64) {
for i, p := range mn {
dv[i] = 1 - 2*p
}
}
func identVar(mn []float64, v []float64) {
copy(v, mn)
}
func identVarDeriv(mn []float64, v []float64) {
one(v)
}
func constVar(mn []float64, v []float64) {
one(v)
}
func constVarDeriv(mn []float64, v []float64) {
zero(v)
}
func squaredVar(mn []float64, v []float64) {
for i, m := range mn {
v[i] = m * m
}
}
func squaredVarDeriv(mn []float64, v []float64) {
for i, m := range mn {
v[i] = 2 * m
}
}
func cubedVar(mn []float64, v []float64) {
for i, m := range mn {
v[i] = m * m * m
}
}
func cubedVarDeriv(mn []float64, v []float64) {
for i, m := range mn {
v[i] = 3 * m * m
}
}
// NewNegBinomVariance returns a variance function for the negative
// binomial family, using the given parameter alpha to determine the
// mean/variance relationship. The variance for mean m is m +
// alpha*m^2.
func NewNegBinomVariance(alpha float64) *Variance {
vaf := func(mn []float64, v []float64) {
for i, m := range mn {
v[i] = m + alpha*m*m
}
}
vad := func(mn []float64, v []float64) {
for i, m := range mn {
v[i] = 1 + 2*alpha*m
}
}
return &Variance{
Var: vaf,
Deriv: vad,
}
}
// NewTweedieVariance returns a variance function for the Tweedie
// family, using the given parameter pw to determine the
// mean/variance relationship. The variance for mean m is m^pw.
func NewTweedieVariance(pw float64) *Variance {
vaf := func(mn []float64, v []float64) {
for i, m := range mn {
v[i] = math.Pow(m, pw)
}
}
vad := func(mn []float64, v []float64) {
for i, m := range mn {
v[i] = pw * math.Pow(m, pw-1)
}
}
return &Variance{
Var: vaf,
Deriv: vad,
}
}
|
