Non-autoregressive System 1 decision engine. Typed choice, score and yes/no decisions over any text in a single forward pass, in 100+ languages, with a router that picks the right checkpoint per request.
Python calibrationclassificationdecision-modelhuggingfacejevmodernbertmultilingualnlppythonpytorchroutingtyped-decisionszero-shot
agent: WithMinConfidence and the confidence gate
Adeshina Lasisi77acf446f9d1
diff --git a/laya-go/agent/agent.go b/laya-go/agent/agent.goindex d73c98d7..0d6d46b0 100644--- a/laya-go/agent/agent.go+++ b/laya-go/agent/agent.go@@ -176,6 +176,11 @@ type call struct {sort boolwindow intstride int++ // gated is set by WithMinConfidence or WithMinConfidenceMap; minConfidence is then a float64+ // or a pyjson.Object, checked by checkMinConfidence.+ gated bool+ minConfidence any}// WithLanguage names the request's language as a BCP 47 tag. Its primary subtag selects a@@ -225,6 +230,14 @@ func (a *Agent) PredictBatch(ctx context.Context, states []any, qs schema.Questiopt(&c)}}+ // Validated up front, as laya does, so a bad threshold fails before any work.+ var g *gate+ if c.gated {+ var err error+ if g, err = checkMinConfidence(c.minConfidence); err != nil {+ return nil, err+ }+ }if err := ctx.Err(); err != nil {return nil, err}@@ -232,7 +245,14 @@ func (a *Agent) PredictBatch(ctx context.Context, states []any, qs schema.Questireturn nil, err}defer a.leave()- return a.predictStates(ctx, states, qs, c)+ preds, err := a.predictStates(ctx, states, qs, c)+ if err != nil {+ return nil, err+ }+ if g != nil {+ g.apply(preds)+ }+ return preds, nil}// predictStates is PredictBatch past the entry checks, for a caller that has already entered.diff --git a/laya-go/agent/gate.go b/laya-go/agent/gate.gonew file mode 100644index 00000000..983ef03d--- /dev/null+++ b/laya-go/agent/gate.go@@ -0,0 +1,238 @@+package agent++import (+ "math"+ "slices"+ "strconv"+ "strings"++ "github.com/NandhaKishorM/laya/laya-go/internal/pyjson"+ "github.com/NandhaKishorM/laya/laya-go/schema"+)++// The states of the confidence gate, laya.confidence.GATE_STATES. There is deliberately no state+// for "no gate was configured": an ungated call writes none of the gate's fields.+const (+ gatePassed = "passed"+ gateAbstained = "abstained"+ gateUnevaluated = "unevaluated"+)++// MinConfidenceError is a refused min_confidence; Error is laya's message.+type MinConfidenceError struct{ Message string }++func (e *MinConfidenceError) Error() string { return e.Message }++// WithMinConfidence turns on the confidence gate of Predict and PredictBatch at one threshold, a+// number in [0, 1], for every answer. Each answer then carries "abstention" ("passed",+// "abstained" or "unevaluated") and "abstention_threshold", and "low_confidence" when it fell+// below the threshold. An answer is gated on its AnswerConfidence, or on Confidence when it has+// no usable AnswerConfidence. A threshold outside [0, 1] or NaN makes the call fail with a+// *MinConfidenceError before anything runs. PredictLong takes no gate.+func WithMinConfidence(threshold float64) CallOption {+ return func(c *call) { c.minConfidence, c.gated = threshold, true }+}++// WithMinConfidenceMap is WithMinConfidence with a threshold per option-count bucket: keys like+// "choice:2", "score:6-10" or "noul:2", and "default" for every bucket the map does not name; a+// bucket it does not name and no default covers is gated at 0. An empty map or any other key+// makes the call fail with a *MinConfidenceError.+func WithMinConfidenceMap(thresholds map[string]float64) CallOption {+ keys := make([]string, 0, len(thresholds))+ for k := range thresholds {+ keys = append(keys, k)+ }+ slices.Sort(keys)+ obj := make(pyjson.Object, len(keys))+ for i, k := range keys {+ obj[i] = pyjson.Member{Key: k, Value: thresholds[k]}+ }+ return func(c *call) { c.minConfidence, c.gated = obj, true }+}++// gate is a validated min_confidence: one threshold, or one per bucket.+type gate struct {+ scalar float64+ buckets map[string]float64 // nil for a scalar gate+}++var bucketSizes = [...]string{"2", "3-5", "6-10", "11+"}++// checkMinConfidence is laya.confidence.check_min_confidence over the Python values a threshold can+// be: a float64 or int, a bool or string (refused), or a pyjson.Object for a map.+func checkMinConfidence(v any) (*gate, error) {+ if m, ok := v.(pyjson.Object); ok {+ return checkMap(m)+ }+ t, err := checkOne(v)+ if err != nil {+ return nil, err+ }+ return &gate{scalar: t}, nil+}++func checkOne(v any) (float64, error) {+ var f float64+ switch x := v.(type) {+ case float64:+ f = x+ case int:+ f = float64(x)+ default:+ return 0, &MinConfidenceError{"min_confidence must be a float in [0.0, 1.0], got " + reprValue(v)}+ }+ if math.IsNaN(f) || math.IsInf(f, 0) || f < 0 || f > 1 {+ return 0, &MinConfidenceError{"min_confidence must be a float in [0.0, 1.0], got " + reprValue(v)}+ }+ return f, nil+}++func checkMap(m pyjson.Object) (*gate, error) {+ if len(m) == 0 {+ return nil, &MinConfidenceError{"a min_confidence map must be a non-empty dict of bucket -> float, got " + reprValue(m)}+ }+ out := make(map[string]float64, len(m))+ for _, mem := range m {+ key, ok := mem.Key.(string)+ if !ok || !validBucketKey(key) {+ return nil, &MinConfidenceError{"min_confidence map keys must be a bucket like 'choice:3-5' or 'default', got " + reprValue(mem.Key)}+ }+ t, err := checkOne(mem.Value)+ if err != nil {+ return nil, err+ }+ out[key] = t+ }+ return &gate{buckets: out}, nil+}++func validBucketKey(k string) bool {+ if k == "default" {+ return true+ }+ qt, size, ok := strings.Cut(k, ":")+ return ok && slices.Contains([]string{"choice", "score", "noul"}, qt) && slices.Contains(bucketSizes[:], size)+}++// reprValue is repr() of the values a threshold can be.+func reprValue(v any) string {+ switch x := v.(type) {+ case nil:+ return "None"+ case bool:+ if x {+ return "True"+ }+ return "False"+ case string:+ return pyjson.Repr(x)+ case int:+ return strconv.Itoa(x)+ case float64:+ switch {+ case math.IsNaN(x):+ return "nan"+ case math.IsInf(x, 1):+ return "inf"+ case math.IsInf(x, -1):+ return "-inf"+ }+ return pyjson.ReprFloat(x)+ case pyjson.Object:+ parts := make([]string, len(x))+ for i, m := range x {+ parts[i] = reprValue(m.Key) + ": " + reprValue(m.Value)+ }+ return "{" + strings.Join(parts, ", ") + "}"+ }+ return "?"+}++// bucketOf is laya's _option_bucket: the answer's type and option-count band, or "" for an answer+// with no bucket (a choice or score with no probabilities). A noul without them counts as 2.+func bucketOf(a schema.Answer) string {+ var qt string+ var k int+ switch x := a.(type) {+ case *schema.ChoiceAnswer:+ qt, k = "choice", len(x.Probabilities)+ case *schema.ScoreAnswer:+ qt, k = "score", len(x.Probabilities)+ case *schema.NoulAnswer:+ qt, k = "noul", 2 // a noul carries no probabilities, which laya counts as two options+ default:+ return ""+ }+ if k == 0 {+ return ""+ }+ size := "11+"+ switch {+ case k <= 2:+ size = "2"+ case k <= 5:+ size = "3-5"+ case k <= 10:+ size = "6-10"+ }+ return qt + ":" + size+}++// threshold is laya's resolve_min_confidence: the bucket's entry, else "default", else 0.+func (g *gate) threshold(a schema.Answer) float64 {+ if g.buckets == nil {+ return g.scalar+ }+ if b := bucketOf(a); b != "" {+ if t, ok := g.buckets[b]; ok {+ return t+ }+ }+ return g.buckets["default"]+}++// usable is a number the gate can compare: finite.+func usable(f float64) bool { return !math.IsNaN(f) && !math.IsInf(f, 0) }++// gateConfidence is laya's _gate_confidence: AnswerConfidence, else Confidence, else none.+func gateConfidence(c schema.Common) (float64, bool) {+ if usable(c.AnswerConfidence) {+ return c.AnswerConfidence, true+ }+ if usable(c.Confidence) {+ return c.Confidence, true+ }+ return 0, false+}++// apply is laya's apply_confidence_gate for a gate that was set: it flags, then reports the state+// and the threshold on every answer, clearing a flag an earlier run left.+func (g *gate) apply(preds []schema.Prediction) {+ for i := range preds {+ for _, ans := range preds[i].Answers {+ var c *schema.Common+ switch x := ans.Answer.(type) {+ case *schema.ChoiceAnswer:+ c = &x.Common+ case *schema.ScoreAnswer:+ c = &x.Common+ case *schema.NoulAnswer:+ c = &x.Common+ default:+ continue+ }+ thr := g.threshold(ans.Answer)+ conf, ok := gateConfidence(*c)+ c.LowConfidence = ok && conf < thr+ switch {+ case c.LowConfidence:+ c.Abstention = gateAbstained+ case !ok:+ c.Abstention = gateUnevaluated+ default:+ c.Abstention = gatePassed+ }+ c.AbstentionThreshold = &thr+ }+ }+}