Files
Assistant/modules/epistemics/domain/adaptive_retrieval.go
T

159 lines
5.4 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package domain
import (
"sort"
"strings"
"git.cin.su/m/Assistant/contracts/epistemics"
)
type ExperienceRetrieval struct {
Positive []epistemics.ExperienceRecord
Negative []epistemics.ExperienceRecord
Contradictions []epistemics.ExperienceRecord
}
// SalienceInput is transient retrieval policy. It deliberately is not stored
// as a permanent importance score on canonical evidence.
type SalienceInput struct {
Relevance int
FocusMatch bool
GoalOrTaskMatch bool
UserIntentStrength int
Importance int
PreviousUsefulness int
CommitmentRelevant bool
Freshness epistemics.FreshnessAssessmentState
Negative bool
ContextCostBytes int
RecordedAtUnixMillis int64
NowUnixMillis int64
}
// ComputeSalience keeps ranking bounded and explainable. Scope and principal
// filtering happen before this function is ever used.
func ComputeSalience(input SalienceInput) int {
score := input.Relevance*100 + input.Importance + input.PreviousUsefulness + input.UserIntentStrength
if input.FocusMatch {
score += 80
}
if input.GoalOrTaskMatch {
score += 60
}
if input.CommitmentRelevant {
score += 40
}
if input.Negative {
score += 30
}
switch input.Freshness {
case epistemics.FreshnessAssessmentCurrent:
score += 40
case epistemics.FreshnessAssessmentAging, epistemics.FreshnessAssessmentAcceptable:
score += 10
case epistemics.FreshnessAssessmentStale, epistemics.FreshnessAssessmentHistoricalOnly, epistemics.FreshnessAssessmentVersionMismatch:
score -= 80
}
if input.NowUnixMillis > input.RecordedAtUnixMillis && input.NowUnixMillis-input.RecordedAtUnixMillis < 24*60*60*1000 {
score += 20
}
return score - input.ContextCostBytes/32
}
// RetrieveExperience filters principal and scope before text relevance. It is
// a derived view over append-only Epistemics records, not a Memory owner.
func RetrieveExperience(records []epistemics.ExperienceRecord, principalID, scopeRef, query string, limit int) ExperienceRetrieval {
if limit < 1 {
limit = 1
}
queryTokens := retrievalTokens(query)
eligible := make([]epistemics.ExperienceRecord, 0, len(records))
for _, record := range records {
if principalID != "" && record.PrincipalID != principalID {
continue
}
if scopeRef != "" && record.ContextScopeRef != scopeRef {
continue
}
if len(queryTokens) > 0 && overlap(queryTokens, retrievalTokens(record.ProblemStatement+" "+record.OutcomeDetail+" "+record.WhySucceededOrFailed)) == 0 {
continue
}
eligible = append(eligible, record)
}
sort.SliceStable(eligible, func(i, j int) bool {
left := experienceSalience(eligible[i], queryTokens)
right := experienceSalience(eligible[j], queryTokens)
if left != right {
return left > right
}
return eligible[i].RecordedAtUnixMillis > eligible[j].RecordedAtUnixMillis
})
result := ExperienceRetrieval{}
for _, record := range eligible {
if len(result.Positive)+len(result.Negative) >= limit {
break
}
switch record.ActualOutcome {
case epistemics.OutcomeSuccess, epistemics.OutcomePartialSuccess:
result.Positive = append(result.Positive, record)
default:
result.Negative = append(result.Negative, record)
if record.ActualOutcome == epistemics.OutcomeConflict || record.ActualOutcome == epistemics.OutcomeUserCorrected || record.ActualOutcome == epistemics.OutcomeStale {
result.Contradictions = append(result.Contradictions, record)
}
}
}
return result
}
func experienceSalience(record epistemics.ExperienceRecord, queryTokens []string) int {
text := record.ProblemStatement + " " + record.OutcomeDetail + " " + record.WhySucceededOrFailed + " " + strings.Join(record.ApplicabilityConditions, " ")
negative := record.ActualOutcome != epistemics.OutcomeSuccess && record.ActualOutcome != epistemics.OutcomePartialSuccess
return ComputeSalience(SalienceInput{
Relevance: overlap(queryTokens, retrievalTokens(text)),
GoalOrTaskMatch: record.GoalRef != "" || record.TaskRef != "",
Importance: int(record.ConfidenceMillis / 10),
CommitmentRelevant: record.ExpectationID != "",
Negative: negative,
ContextCostBytes: len([]byte(text)),
RecordedAtUnixMillis: record.RecordedAtUnixMillis,
NowUnixMillis: record.RecordedAtUnixMillis,
})
}
func BuildConsolidationCandidates(records []epistemics.ExperienceRecord) []epistemics.ConsolidationCandidate {
byProblem := map[string][]epistemics.ExperienceRecord{}
for _, record := range records {
key := strings.TrimSpace(strings.ToLower(record.ProblemStatement))
if key != "" {
byProblem[key] = append(byProblem[key], record)
}
}
result := make([]epistemics.ConsolidationCandidate, 0, len(byProblem))
for problem, grouped := range byProblem {
refs := make([]epistemics.ExperienceRecordID, 0, len(grouped))
for _, record := range grouped {
refs = append(refs, record.ID)
}
result = append(result, epistemics.ConsolidationCandidate{EpisodeRef: "derived:experience:" + problem, ExperienceRefs: refs, PropositionText: problem, SkillCandidate: len(grouped) > 1})
}
return result
}
func retrievalTokens(value string) []string {
return strings.FieldsFunc(strings.ToLower(value), func(r rune) bool { return r < '0' || r > 'z' && (r < 'а' || r > 'я') })
}
func overlap(left, right []string) int {
seen := map[string]bool{}
for _, v := range left {
seen[v] = true
}
n := 0
for _, v := range right {
if seen[v] {
n++
}
}
return n
}