/
param.go
119 lines (98 loc) · 2.77 KB
/
param.go
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
package gosvm
/*
#include "wrap.h"
*/
import "C"
// Parameters for training an SVM.
type Parameters struct {
SVMType SVMType
Kernel Kernel
CacheSize float64 // Cache size in MB
Epsilon float64 // Stopping criterium
Shrinking bool // Apply shrinking
Probability bool // Provide probability estimates
}
// Default training parameters: C-SVM classification with a constraint
// violation cost of 1, a linear kernel, a cache size of 1 MB,
// epsilon=0.001 as the stopping criterium, and no shrinking.
func DefaultParameters() Parameters {
return Parameters{
NewCSVC(1),
NewLinearKernel(),
1,
0.001,
false,
false}
}
// This type represents a kernel.
type Kernel struct {
kernelType C.int
gamma C.double
coef0 C.double
degree C.int
}
// Create a linear kernel.
func NewLinearKernel() Kernel {
return Kernel{C.LINEAR, 0, 0, 0}
}
// Create a polynomial kernel.
func NewPolynomialKernel(gamma, coef0 float64, degree int) Kernel {
return Kernel{C.POLY, C.double(gamma), C.double(coef0), C.int(degree)}
}
// Create a Radial Basis Function (RBF) kernel.
func NewRBFKernel(gamma float64) Kernel {
return Kernel{C.RBF, C.double(gamma), 0, 0}
}
// Create a sigmoid kernel.
func NewSigmoidKernel(gamma, coef0 float64) Kernel {
return Kernel{C.SIGMOID, C.double(gamma), C.double(coef0), 0}
}
// Support vector machine type configuration
type SVMType struct {
svmType C.int
cost C.double
nu C.double
epsilon C.double
}
// C-Support Vector Classification (C-SVC)
func NewCSVC(cost float64) SVMType {
return SVMType{C.C_SVC, C.double(cost), 0, 0}
}
// Nu-Support Vector Classification (nu-SVC).
func NewNuSVC(cost, nu float64) SVMType {
return SVMType{C.NU_SVC, C.double(cost), C.double(nu), 0}
}
// One-class SVM.
func NewOneClass(nu float64) SVMType {
return SVMType{C.ONE_CLASS, 0, C.double(nu), 0}
}
// Epsilon support vector regression (epsilon-SVR).
func NewEpsilonSVR(cost, epsilon float64) SVMType {
return SVMType{C.EPSILON_SVR, C.double(cost), 0, C.double(epsilon)}
}
// Nu-support vector regression (nu-SVR).
func NewNuSVR(cost, nu float64) SVMType {
return SVMType{C.NU_SVR, C.double(cost), C.double(nu), 0}
}
func toCParameter(param Parameters) *C.svm_parameter_t {
cParam := C.parameter_new()
// SVM type parameters
cParam.svm_type = param.SVMType.svmType
cParam.C = param.SVMType.cost
cParam.nu = param.SVMType.nu
cParam.p = param.SVMType.epsilon
// Kernel type parameters
cParam.kernel_type = param.Kernel.kernelType
cParam.gamma = param.Kernel.gamma
cParam.coef0 = param.Kernel.coef0
cParam.degree = param.Kernel.degree
cParam.cache_size = C.double(param.CacheSize)
cParam.eps = C.double(param.Epsilon)
if param.Shrinking {
cParam.shrinking = 1
}
if param.Probability {
cParam.probability = 1
}
return cParam
}