func (s *stateOutBlockRResult) PropagateRGradient(u, uR []linalg.Vector, su []RStateGrad, rg autofunc.RGradient, g autofunc.Gradient) []RStateGrad { downstream := make([]RStateGrad, len(s.WrappedOut.Outputs())) for i := range s.WrappedOut.Outputs() { var vec, vecR linalg.Vector if u != nil { vec = u[i].Copy() vecR = uR[i].Copy() } if su != nil && su[i] != nil { sVec := su[i].(VecRStateGrad) if vec == nil { vec = sVec.State.Copy() vecR = sVec.RState.Copy() } else { vec.Add(sVec.State) vecR.Add(sVec.RState) } } if vec != nil { downstream[i] = VecRStateGrad{State: vec, RState: vecR} } } return s.WrappedOut.PropagateRGradient(nil, nil, downstream, rg, g) }
func (s *SumClassifier) Classify(list SampleList) linalg.Vector { if len(s.Classifiers) == 0 { return make(linalg.Vector, list.Len()) } else if len(s.Classifiers) != len(s.Weights) { panic("classifier count must match weight count") } var res linalg.Vector for i, c := range s.Classifiers { w := s.Weights[i] if res == nil { res = c.Classify(list).Scale(w) } else { res.Add(c.Classify(list).Scale(w)) } } return res }
func (s *stateOutBlockResult) PropagateGradient(u []linalg.Vector, su []StateGrad, g autofunc.Gradient) []StateGrad { downstream := make([]StateGrad, len(s.WrappedOut.Outputs())) for i := range s.WrappedOut.Outputs() { var vec linalg.Vector if u != nil { vec = u[i].Copy() } if su != nil && su[i] != nil { sVec := su[i].(VecStateGrad) if vec == nil { vec = linalg.Vector(sVec).Copy() } else { vec.Add(linalg.Vector(sVec)) } } if vec != nil { downstream[i] = VecStateGrad(vec) } } return s.WrappedOut.PropagateGradient(nil, downstream, g) }
// Step adds d.Scale(amount) to coeffs. // If any of the entries in coeffs hits a // constraint, then the step is stopped // short and true is returned to indicate // that a new constraint has been added. // // This may modify d in any way it pleases. func (a *activeSet) Step(coeffs, d linalg.Vector, amount float64) bool { var maxStep, minStep float64 var maxIdx, minIdx int isFirst := true for i, x := range d { if x == 0 { continue } coeff := coeffs[i] maxValue := (a.MaxCoeff - coeff) / x minValue := -coeff / x if x < 0 { maxValue, minValue = minValue, maxValue } if isFirst { isFirst = false minStep, maxStep = minValue, maxValue maxIdx, minIdx = i, i } else { if minValue > minStep { minStep = minValue minIdx = i } if maxValue < maxStep { maxStep = maxValue maxIdx = i } } } if isFirst { return false } if amount < minStep { coeffs.Add(d.Scale(minStep)) a.addConstraint(coeffs, minIdx) } else if amount > maxStep { coeffs.Add(d.Scale(maxStep)) a.addConstraint(coeffs, maxIdx) } else { coeffs.Add(d.Scale(amount)) return false } return true }