159 lines
5.4 KiB
Go
159 lines
5.4 KiB
Go
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
|
||
}
|