本文整理汇总了Golang中github.com/gonum/matrix/mat64.Dense.At方法的典型用法代码示例。如果您正苦于以下问题:Golang Dense.At方法的具体用法?Golang Dense.At怎么用?Golang Dense.At使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类github.com/gonum/matrix/mat64.Dense
的用法示例。
在下文中一共展示了Dense.At方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: Cov
// Cov returns the covariance between a set of data points based on the current
// GP fit.
func (g *GP) Cov(m *mat64.SymDense, x mat64.Matrix) *mat64.SymDense {
if m != nil {
// TODO(btracey): Make this k**
panic("resuing m not coded")
}
// The joint covariance matrix is
// K(x_*, k_*) - k(x_*, x) k(x,x)^-1 k(x, x*)
nSamp, nDim := x.Dims()
if nDim != g.inputDim {
panic(badInputLength)
}
// Compute K(x_*, x) K(x, x)^-1 K(x, x_*)
kstar := g.formKStar(x)
var tmp mat64.Dense
tmp.SolveCholesky(g.cholK, kstar)
var tmp2 mat64.Dense
tmp2.Mul(kstar.T(), &tmp)
// Compute k(x_*, x_*) and perform the subtraction.
kstarstar := mat64.NewSymDense(nSamp, nil)
for i := 0; i < nSamp; i++ {
for j := i; j < nSamp; j++ {
v := g.kernel.Distance(mat64.Row(nil, i, x), mat64.Row(nil, j, x))
if i == j {
v += g.noise
}
kstarstar.SetSym(i, j, v-tmp2.At(i, j))
}
}
return kstarstar
}
示例2: toFeatureNodes
func toFeatureNodes(X *mat64.Dense) []*C.struct_feature_node {
featureNodes := []*C.struct_feature_node{}
nRows, nCols := X.Dims()
for i := 0; i < nRows; i++ {
row := []C.struct_feature_node{}
for j := 0; j < nCols; j++ {
val := X.At(i, j)
if val != 0 {
row = append(row, C.struct_feature_node{
index: C.int(j + 1),
value: C.double(val),
})
}
}
row = append(row, C.struct_feature_node{
index: C.int(-1),
value: C.double(0),
})
featureNodes = append(featureNodes, &row[0])
}
return featureNodes
}
示例3: rowSum
func rowSum(matrix *mat64.Dense, rowId int) float64 {
_, col := matrix.Dims()
sum := float64(0)
for c := 0; c < col; c++ {
sum += matrix.At(rowId, c)
}
return sum
}
示例4: colSum
func colSum(matrix *mat64.Dense, colId int) float64 {
row, _ := matrix.Dims()
sum := float64(0)
for r := 0; r < row; r++ {
sum += matrix.At(r, colId)
}
return sum
}
示例5: SetScale
// SetScale sets a linear scale between 0 and 1. If no data
// points. If the minimum and maximum value are identical in
// a dimension, the minimum and maximum values will be set to
// that value +/- 0.5 and a
func (l *Linear) SetScale(data *mat64.Dense) error {
rows, dim := data.Dims()
if rows < 2 {
return errors.New("scale: less than two inputs")
}
// Generate data for min and max if they don't already exist
if len(l.Min) < dim {
l.Min = make([]float64, dim)
} else {
l.Min = l.Min[0:dim]
}
if len(l.Max) < dim {
l.Max = make([]float64, dim)
} else {
l.Max = l.Max[0:dim]
}
for i := range l.Min {
l.Min[i] = math.Inf(1)
}
for i := range l.Max {
l.Max[i] = math.Inf(-1)
}
// Find the minimum and maximum in each dimension
for i := 0; i < rows; i++ {
for j := 0; j < dim; j++ {
val := data.At(i, j)
if val < l.Min[j] {
l.Min[j] = val
}
if val > l.Max[j] {
l.Max[j] = val
}
}
}
l.Scaled = true
l.Dim = dim
var unifError *UniformDimension
// Check that the maximum and minimum values are not identical
for i := range l.Min {
if l.Min[i] == l.Max[i] {
if unifError == nil {
unifError = &UniformDimension{}
}
unifError.Dims = append(unifError.Dims, i)
l.Min[i] -= 0.5
l.Max[i] += 0.5
}
}
if unifError != nil {
return unifError
}
return nil
}
示例6: UpdateBias
// UpdateBias computes B = B + l.E and updates the bias weights
// from a size * 1 back-propagated error vector.
func (n *Network) UpdateBias(err *mat64.Dense, learnRate float64) {
for i, b := range n.biases {
if i < n.input {
continue
}
n.biases[i] = b + err.At(i, 0)*learnRate
}
}
示例7: regionQuery
func regionQuery(p int, ret *big.Int, dist *mat64.Dense, eps float64) *big.Int {
rows, _ := dist.Dims()
// Return any points within the Eps neighbourhood
for i := 0; i < rows; i++ {
if dist.At(p, i) <= eps {
ret = ret.SetBit(ret, i, 1) // Mark as neighbour
}
}
return ret
}
示例8: Mat64ToGcvMat
// Convert *mat64.Dense to Mat
func Mat64ToGcvMat(mat *mat64.Dense) GcvMat {
row, col := mat.Dims()
rawData := NewGcvFloat64Vector(int64(row * col))
for i := 0; i < row; i++ {
for j := 0; j < col; j++ {
rawData.Set(i*col+j, mat.At(i, j))
}
}
return Mat64ToGcvMat_(row, col, rawData)
}
示例9: Fit
func (nb *NaiveBayes) Fit(X, y *mat64.Dense) {
nSamples, nFeatures := X.Dims()
tokensTotal := 0
langsTotal, _ := y.Dims()
langsCount := histogram(y.Col(nil, 0))
tokensTotalPerLang := map[int]int{}
tokenCountPerLang := map[int](map[int]int){}
for i := 0; i < nSamples; i++ {
langIdx := int(y.At(i, 0))
for j := 0; j < nFeatures; j++ {
tokensTotal += int(X.At(i, j))
tokensTotalPerLang[langIdx] += int(X.At(i, j))
if _, ok := tokenCountPerLang[langIdx]; !ok {
tokenCountPerLang[langIdx] = map[int]int{}
}
tokenCountPerLang[langIdx][j] += int(X.At(i, j))
}
}
params := nbParams{
TokensTotal: tokensTotal,
LangsTotal: langsTotal,
LangsCount: langsCount,
TokensTotalPerLang: tokensTotalPerLang,
TokenCountPerLang: tokenCountPerLang,
}
nb.params = params
}
示例10: StackConstr
func StackConstr(low, A, up *mat64.Dense) (stackA, b *mat64.Dense, ranges []float64) {
neglow := &mat64.Dense{}
neglow.Scale(-1, low)
b = &mat64.Dense{}
b.Stack(up, neglow)
negA := &mat64.Dense{}
negA.Scale(-1, A)
stackA = &mat64.Dense{}
stackA.Stack(A, negA)
// capture the range of each constraint from A because this information is
// lost when converting from "low <= Ax <= up" via stacking to "Ax <= up".
m, _ := A.Dims()
ranges = make([]float64, m, 2*m)
for i := 0; i < m; i++ {
ranges[i] = up.At(i, 0) - low.At(i, 0)
if ranges[i] == 0 {
if up.At(i, 0) == 0 {
ranges[i] = 1
} else {
ranges[i] = up.At(i, 0)
}
}
}
ranges = append(ranges, ranges...)
return stackA, b, ranges
}
示例11: Fit
func (lr *LinearRegression) Fit(inst *base.Instances) error {
if inst.Rows < inst.GetAttributeCount() {
return NotEnoughDataError
}
// Split into two matrices, observed results (dependent variable y)
// and the explanatory variables (X) - see http://en.wikipedia.org/wiki/Linear_regression
observed := mat64.NewDense(inst.Rows, 1, nil)
explVariables := mat64.NewDense(inst.Rows, inst.GetAttributeCount(), nil)
for i := 0; i < inst.Rows; i++ {
observed.Set(i, 0, inst.Get(i, inst.ClassIndex)) // Set observed data
for j := 0; j < inst.GetAttributeCount(); j++ {
if j == 0 {
// Set intercepts to 1.0
// Could / should be done better: http://www.theanalysisfactor.com/interpret-the-intercept/
explVariables.Set(i, 0, 1.0)
} else {
explVariables.Set(i, j, inst.Get(i, j-1))
}
}
}
n := inst.GetAttributeCount()
qr := mat64.QR(explVariables)
q := qr.Q()
reg := qr.R()
var transposed, qty mat64.Dense
transposed.TCopy(q)
qty.Mul(&transposed, observed)
regressionCoefficients := make([]float64, n)
for i := n - 1; i >= 0; i-- {
regressionCoefficients[i] = qty.At(i, 0)
for j := i + 1; j < n; j++ {
regressionCoefficients[i] -= regressionCoefficients[j] * reg.At(i, j)
}
regressionCoefficients[i] /= reg.At(i, i)
}
lr.disturbance = regressionCoefficients[0]
lr.regressionCoefficients = regressionCoefficients[1:]
lr.fitted = true
return nil
}
示例12: Distance
// Manhattan distance, also known as L1 distance.
// Compute sum of absolute values of elements.
func (self *Manhattan) Distance(vectorX *mat64.Dense, vectorY *mat64.Dense) float64 {
r1, c1 := vectorX.Dims()
r2, c2 := vectorY.Dims()
if r1 != r2 || c1 != c2 {
panic(mat64.ErrShape)
}
result := .0
for i := 0; i < r1; i++ {
for j := 0; j < c1; j++ {
result += math.Abs(vectorX.At(i, j) - vectorY.At(i, j))
}
}
return result
}
示例13: predict
// wrapper for predict, assumes all inputs are correct
func predict(input []float64, features *mat64.Dense, b []float64, featureWeights *mat64.Dense, output []float64) {
for i := range output {
output[i] = 0
}
nFeatures, _ := features.Dims()
_, outputDim := featureWeights.Dims()
sqrt2OverD := math.Sqrt(2.0 / float64(nFeatures))
//for i, feature := range features {
for i := 0; i < nFeatures; i++ {
z := computeZ(input, features.RowView(i), b[i], sqrt2OverD)
for j := 0; j < outputDim; j++ {
output[j] += z * featureWeights.At(i, j)
}
}
}
示例14: Distance
func (self *Chebyshev) Distance(vectorX *mat64.Dense, vectorY *mat64.Dense) float64 {
r1, c1 := vectorX.Dims()
r2, c2 := vectorY.Dims()
if r1 != r2 || c1 != c2 {
panic(mat64.ErrShape)
}
max := float64(0)
for i := 0; i < r1; i++ {
for j := 0; j < c1; j++ {
max = math.Max(max, math.Abs(vectorX.At(i, j)-vectorY.At(i, j)))
}
}
return max
}
示例15: cost
func cost(y, yHat *mat64.Dense) float64 {
// TODO add runtime check that y and yHat have the same dimensions
rows, cols := y.Dims()
errorSquares := []float64{}
for row := 0; row < rows; row++ {
for col := 0; col < cols; col++ {
yValue := y.At(row, col)
yHatValue := yHat.At(row, col)
error := 0.5 * math.Pow((yValue-yHatValue), 2)
errorSquares = append(errorSquares, error)
}
}
var errorSum float64
for _, error := range errorSquares {
errorSum += error
}
return errorSum
}