数据飞轮与持续迭代

type SampleCollector struct {
    store    SampleStore    // 存储后端(对象存储/数据库)
    sampler  *Sampler       // 采样策略
}

type Sample struct {
    ID            string
    Text          string
    GroupID       string
    Timestamp     time.Time
    ModelPrediction ModelResult
    LLMResult     *LLMResult
    Source        SampleSource   // Uncertain / UserReport / UserAppeal / Disagreement
    HumanLabel    *string        // 人工标注后回填
}

type SampleSource int

const (
    SourceUncertain   SampleSource = iota // 模型不确定
    SourceUserReport                       // 用户举报
    SourceUserAppeal                       // 用户申诉
    SourceDisagreement                     // 小模型与 LLM 不一致
)

func (c *SampleCollector) MaybeCollect(ctx context.Context, msg *Message, result ModelResult, llmResult *LLMResult) {
    source := c.determineSource(result, llmResult)
    if source == -1 {
        return // 不需要收集
    }

    // 不确定样本按比例采样,避免量太大
    if source == SourceUncertain && !c.sampler.ShouldSample() {
        return
    }

    sample := Sample{
        ID:              msg.ID,
        Text:            msg.Text,
        GroupID:         msg.GroupID,
        Timestamp:       time.Now(),
        ModelPrediction: result,
        LLMResult:       llmResult,
        Source:          source,
    }

    // 异步写入,不影响主流程延迟
    go c.store.Save(context.Background(), sample)
}

func (c *SampleCollector) determineSource(result ModelResult, llmResult *LLMResult) SampleSource {
    // 模型置信度在灰色地带
    maxScore := float32(0)
    for _, s := range result.Scores {
        if s > maxScore {
            maxScore = s
        }
    }
    if maxScore > 0.4 && maxScore < 0.7 {
        return SourceUncertain
    }

    // 小模型与 LLM 判断不一致
    if llmResult != nil && result.Action.String() != llmResult.Action {
        return SourceDisagreement
    }

    return -1
}

// 用户举报
func (m *Moderator) HandleReport(ctx context.Context, req ReportRequest) error {
    sample := Sample{
        ID:        req.MessageID,
        Text:      req.MessageText,
        GroupID:   req.GroupID,
        Timestamp: time.Now(),
        Source:    SourceUserReport,
    }
    return m.collector.store.Save(ctx, sample)
}

// 用户申诉(被误拦截后)
func (m *Moderator) HandleAppeal(ctx context.Context, req AppealRequest) error {
    sample := Sample{
        ID:        req.MessageID,
        Text:      req.MessageText,
        GroupID:   req.GroupID,
        Timestamp: time.Now(),
        Source:    SourceUserAppeal,
        // 申诉意味着用户认为不应该被拦截,这是一个隐式的 "safe" 标签
    }
    if err := m.collector.store.Save(ctx, sample); err != nil {
        return err
    }
    // 立即放行该消息(申诉后不等人工审核)
    return m.recallBlock(ctx, req.MessageID)
}

type AutoLabeler struct {
    rules []LabelRule
}

type LabelRule struct {
    Source    SampleSource
    Condition func(Sample) bool
    Label     string
}

var defaultRules = []LabelRule{
    {
        Source: SourceUserReport,
        Condition: func(s Sample) bool {
            // 用户举报 + LLM 也判 block → 高置信度违规
            return s.LLMResult != nil && s.LLMResult.Action == "block"
        },
        Label: "violation",
    },
    {
        Source: SourceUserAppeal,
        Condition: func(s Sample) bool {
            // 用户申诉 + LLM 判 pass → 高置信度误判
            return s.LLMResult != nil && s.LLMResult.Action == "pass"
        },
        Label: "safe",
    },
}

type ModelVersion struct {
    Version      string    // "v2.3.1"
    CreatedAt    time.Time
    TrainingData struct {
        Size      int       // 样本数
        DateRange [2]time.Time
        Sources   []string  // ["user_reports", "auto_labeled", "human_labeled"]
    }
    Metrics struct {
        Accuracy       float64
        FalsePositive  float64
        FalseNegative  float64
        Latency_P99_ms float64
    }
    Status     ModelStatus
    ChangeLog  string // "新增谐音变体样本 5000 条,FPR 从 1.2% 降至 0.7%"
}

type RetrainTrigger struct {
    minNewSamples    int           // 最少新样本数
    maxInterval      time.Duration // 最长间隔
    accuracyDrop     float64       // 线上准确率下降阈值
}

func (t *RetrainTrigger) ShouldRetrain(stats SystemStats) (bool, string) {
    // 条件 1: 积累了足够多新标注样本
    if stats.NewLabeledSamples > t.minNewSamples {
        return true, fmt.Sprintf("new samples: %d", stats.NewLabeledSamples)
    }

    // 条件 2: 距上次训练超过最大间隔
    if time.Since(stats.LastTrainTime) > t.maxInterval {
        return true, "max interval exceeded"
    }

    // 条件 3: 线上指标恶化
    if stats.CurrentAccuracy < stats.BaselineAccuracy-t.accuracyDrop {
        return true, fmt.Sprintf("accuracy dropped: %.2f → %.2f",
            stats.BaselineAccuracy, stats.CurrentAccuracy)
    }

    return false, ""
}

type UpdateDecision struct {
    Type    UpdateType
    Reason  string
    Effort  string // "5min" / "2h" / "3days"
}

type UpdateType int

const (
    UpdateRules     UpdateType = iota // 改规则,5 分钟生效
    UpdateThreshold                    // 改阈值,即时生效
    UpdateModel                        // 重训模型,3-7 天周期
    UpdateBoth                         // 规则先顶住,同时启动重训
)

type EvalDataset struct {
    Name       string
    Samples    []EvalSample
    UpdatedAt  time.Time
}

type EvalSample struct {
    Text       string
    Label      string   // 人工标注的正确答案
    Difficulty string   // "easy" / "medium" / "hard"
    Category   string   // "toxic" / "spam" / "sarcasm" / "normal"
}

// 评估新模型
func EvaluateModel(model *Model, evalSet *EvalDataset) EvalReport {
    var correct, total int
    var fp, fn int // false positive, false negative

    for _, sample := range evalSet.Samples {
        prediction := model.Predict(sample.Text)
        total++

        if prediction == sample.Label {
            correct++
        } else if prediction == "violation" && sample.Label == "safe" {
            fp++
        } else if prediction == "safe" && sample.Label != "safe" {
            fn++
        }
    }

    return EvalReport{
        Accuracy:      float64(correct) / float64(total),
        FalsePositive: float64(fp) / float64(total),
        FalseNegative: float64(fn) / float64(total),
    }
}