v6ole/silk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 修复 AI 风险语义并隔离 Mock 数据

Browse Source
This commit is contained in:
weijuesen
2026-08-14 01:16:50 +08:00
parent 839ba91354
commit 74d1948d68
29 changed files with 650 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server-go/internal/service/ai_client.go
+30 -2
View File
@@ -29,8 +29,36 @@ type AIDetection struct {
// AIDetectResponse /detect 响应
type AIDetectResponse struct {
Model string `json:"model"`
Detections []AIDetection `json:"detections"`
Model string `json:"model"`
ModelVersion string `json:"modelVersion"`
IsMock bool `json:"isMock"`
Status string `json:"status"`
AbnormalProbability float64 `json:"abnormalProbability"`
Detections []AIDetection `json:"detections"`
}
// AIDetectionStatus 从检测结果归纳 AI 状态；空检测或 unknown 不当作 healthy。
func AIDetectionStatus(detections []AIDetection) string {
if len(detections) == 0 {
return "unknown"
}
healthySeen := false
unknownSeen := false
for _, d := range detections {
class := strings.ToLower(strings.TrimSpace(d.ClassName))
switch class {
case "healthy":
healthySeen = true
case "", "unknown":
unknownSeen = true
default:
return "abnormal"
}
}
if healthySeen && !unknownSeen {
return "healthy"
}
return "unknown"
}
// AIClient ai-service HTTP 客户端
server-go/internal/service/ai_client_test.go
+29 -1
View File
@@ -24,7 +24,11 @@ func TestAIClientDetectParsesResult(t *testing.T) {
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{
"model": "mock",
"model": "mock",
"modelVersion": "silk-yolo-2026.08.1",
"isMock": true,
"status": "abnormal",
"abnormalProbability": 0.93,
"detections": []map[string]any{
{"bbox": map[string]float64{"x": 1, "y": 2, "w": 3, "h": 4}, "class": "sick", "confidence": 0.93},
},
@@ -40,6 +44,15 @@ func TestAIClientDetectParsesResult(t *testing.T) {
if res.Model != "mock" {
t.Errorf("model = %s, want mock", res.Model)
}
if res.ModelVersion != "silk-yolo-2026.08.1" {
t.Errorf("modelVersion = %s, want silk-yolo-2026.08.1", res.ModelVersion)
}
if !res.IsMock {
t.Error("isMock 应解析为 true")
}
if res.Status != "abnormal" || res.AbnormalProbability != 0.93 {
t.Errorf("AI 语义字段解析不正确: %+v", res)
}
if len(res.Detections) != 1 {
t.Fatalf("detections 数量 = %d, want 1", len(res.Detections))
}
@@ -49,6 +62,21 @@ func TestAIClientDetectParsesResult(t *testing.T) {
}
}
func TestAIDetectionStatus(t *testing.T) {
if got := AIDetectionStatus(nil); got != "unknown" {
t.Errorf("空检测应为 unknown，实际 %s", got)
}
if got := AIDetectionStatus([]AIDetection{{ClassName: "healthy"}}); got != "healthy" {
t.Errorf("全健康应为 healthy，实际 %s", got)
}
if got := AIDetectionStatus([]AIDetection{{ClassName: "unknown"}}); got != "unknown" {
t.Errorf("unknown 应为 unknown，实际 %s", got)
}
if got := AIDetectionStatus([]AIDetection{{ClassName: "sick"}}); got != "abnormal" {
t.Errorf("异常类别应为 abnormal，实际 %s", got)
}
}
func TestAIClientDetectServerError(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "boom", http.StatusInternalServerError)
server-go/internal/service/cross_validate.go
+19 -4
View File
@@ -1,5 +1,7 @@
package service
import "strings"
// CrossValidate 交叉验证：AI 检测结果 vs LAMP 检测结果（规格书：一致→确认诊断；不一致→升级专家会诊）
func CrossValidate(aiClass, lampResult string, lampDiseases []string) (bool, string) {
switch {
@@ -7,6 +9,8 @@ func CrossValidate(aiClass, lampResult string, lampDiseases []string) (bool, str
return false, "LAMP 判读无效，建议复检或专家会诊"
case aiClass == "":
return false, "未找到关联巡检记录，暂无法交叉验证"
case aiClass == "unknown":
return false, "AI 结果未知，建议复检或专家会诊"
case aiClass == "sick" && lampResult == "positive":
return true, "AI 检出异常与 LAMP 阳性一致，确认诊断"
case aiClass == "healthy" && lampResult == "negative":
@@ -20,15 +24,26 @@ func CrossValidate(aiClass, lampResult string, lampDiseases []string) (bool, str
}
}
// AIClassFromDetections 从巡检检测结果归纳 AI 结论（任一非 healthy 视为 sick）
// AIClassFromDetections 从巡检检测结果归纳 AI 结论；空检测或 unknown 不当作 healthy。
func AIClassFromDetections(detections []AIDetection) string {
if len(detections) == 0 {
return ""
return "unknown"
}
healthySeen := false
unknownSeen := false
for _, d := range detections {
if d.ClassName != "healthy" {
class := strings.ToLower(strings.TrimSpace(d.ClassName))
switch class {
case "healthy":
healthySeen = true
case "", "unknown":
unknownSeen = true
default:
return "sick"
}
}
return "healthy"
if healthySeen && !unknownSeen {
return "healthy"
}
return "unknown"
}
server-go/internal/service/cross_validate_test.go
+6 -2
View File
@@ -13,6 +13,7 @@ func TestCrossValidate(t *testing.T) {
{"AI健康+LAMP阴性 一致", "healthy", "negative", true},
{"AI异常+LAMP阴性 不一致", "sick", "negative", false},
{"AI健康+LAMP阳性 不一致", "healthy", "positive", false},
{"AI未知+LAMP阳性 不一致", "unknown", "positive", false},
{"LAMP无效 不一致", "sick", "invalid", false},
{"无AI记录 不一致", "", "positive", false},
}
@@ -28,8 +29,8 @@ func TestCrossValidate(t *testing.T) {
}
func TestAIClassFromDetections(t *testing.T) {
if got := AIClassFromDetections(nil); got != "" {
t.Errorf("空检测应为空，实际 %s", got)
if got := AIClassFromDetections(nil); got != "unknown" {
t.Errorf("空检测应为 unknown，实际 %s", got)
}
if got := AIClassFromDetections([]AIDetection{{ClassName: "healthy", Confidence: 0.9}}); got != "healthy" {
t.Errorf("全健康应为 healthy，实际 %s", got)
@@ -37,4 +38,7 @@ func TestAIClassFromDetections(t *testing.T) {
if got := AIClassFromDetections([]AIDetection{{ClassName: "healthy"}, {ClassName: "sick", Confidence: 0.6}}); got != "sick" {
t.Errorf("含 sick 应为 sick，实际 %s", got)
}
if got := AIClassFromDetections([]AIDetection{{ClassName: "unknown", Confidence: 0.6}}); got != "unknown" {
t.Errorf("unknown 应为 unknown，实际 %s", got)
}
}
server-go/internal/service/risk.go
+108 -12
View File
@@ -1,21 +1,117 @@
package service
import "math"
import (
"math"
"strings"
)
// RiskInput 风险评分输入（各系数取值 0~1）
// RiskRuleVersion 当前风险规则版本；权重仍沿用试点公式，待数据校准后升版。
const RiskRuleVersion = "risk-v2-2026.08.14"
// RiskInput 风险评分输入。nil 表示未采集，不能按 0 参与归一化。
type RiskInput struct {
AI float64 // AI 识别置信度（权重 0.5）
Env float64 // 环境风险系数（权重 0.2）
Stage float64 // 饲养阶段风险系数（权重 0.15）
Uniformity float64 // 群体整齐度偏离度（权重 0.15）
AI *float64 // AI 异常概率（权重 0.5）
Env *float64 // 环境风险系数（权重 0.2）
Stage *float64 // 饲养阶段风险系数（权重 0.15）
Uniformity *float64 // 群体整齐度偏离度（权重 0.15）
ModelVersion string
}
// ComputeRiskScore 按规格书 3.1.4 公式计算 0~100 风险分：
// 风险分 = 0.5×AI置信度 + 0.2×环境系数 + 0.15×阶段系数 + 0.15×整齐度偏离度
func ComputeRiskScore(in RiskInput) float64 {
score := 0.5*in.AI + 0.2*in.Env + 0.15*in.Stage + 0.15*in.Uniformity
score = math.Max(0, math.Min(1, score))
return score * 100
// RiskAssessment 可解释风险输出。
type RiskAssessment struct {
Score float64 `json:"score"`
Level string `json:"level"`
Confidence string `json:"confidence"`
ModelVersion string `json:"modelVersion"`
RuleVersion string `json:"ruleVersion"`
Components map[string]*float64 `json:"components"`
Missing []string `json:"missing"`
}
// ComputeRiskScore 按可用权重归一化计算 0~100 风险分，缺失组件返回 null。
// 当前 0.5/0.2/0.15/0.15 是待试点校准规则，不是科学结论。
func ComputeRiskScore(in RiskInput) RiskAssessment {
defs := []struct {
key string
weight float64
value *float64
}{
{"aiAbnormalProbability", 0.5, in.AI},
{"environment", 0.2, in.Env},
{"stage", 0.15, in.Stage},
{"uniformity", 0.15, in.Uniformity},
}
components := make(map[string]*float64, len(defs))
missing := make([]string, 0, len(defs))
weighted := 0.0
totalWeight := 0.0
for _, def := range defs {
if def.value == nil {
components[def.key] = nil
missing = append(missing, def.key)
continue
}
value := clamp01(*def.value)
components[def.key] = &value
weighted += def.weight * value
totalWeight += def.weight
}
score := 0.0
if totalWeight > 0 {
score = math.Round(clamp01(weighted/totalWeight)*10000) / 100
}
return RiskAssessment{
Score: score,
Level: RiskLevel(score),
Confidence: RiskConfidence(in),
ModelVersion: in.ModelVersion,
RuleVersion: RiskRuleVersion,
Components: components,
Missing: missing,
}
}
// RiskConfidence 当前仅给出 low/medium/unknown，避免把未校准规则描述为 high。
func RiskConfidence(in RiskInput) string {
if in.AI == nil {
return "unknown"
}
if *in.AI >= 0.25 {
return "medium"
}
return "low"
}
// AbnormalProbability 从 AI 检测结果计算异常概率：healthy/unknown 不贡献风险。
// abnormalClasses 可选；缺省时任一非 healthy/unknown 类别都视为异常类别。
func AbnormalProbability(detections []AIDetection, abnormalClasses ...string) float64 {
configured := make(map[string]struct{}, len(abnormalClasses))
for _, class := range abnormalClasses {
if class = strings.ToLower(strings.TrimSpace(class)); class != "" {
configured[class] = struct{}{}
}
}
best := 0.0
for _, d := range detections {
class := strings.ToLower(strings.TrimSpace(d.ClassName))
if class == "" || class == "healthy" || class == "unknown" {
continue
}
if len(configured) > 0 {
if _, ok := configured[class]; !ok {
continue
}
}
if d.Confidence > best {
best = d.Confidence
}
}
return clamp01(best)
}
func clamp01(v float64) float64 {
return math.Max(0, math.Min(1, v))
}
// RiskLevel 按规格书 3.1.4 分级：绿 0-30 / 黄 31-60 / 橙 61-80 / 红 81-100
server-go/internal/service/risk_test.go
+103 -26
View File
@@ -1,43 +1,120 @@
package service
import "testing"
import (
"math"
"testing"
)
func f(v float64) *float64 { return &v }
func ptr(v float64) *float64 { return &v }
func TestComputeRiskScoreWeights(t *testing.T) {
// 全 1：0.5*1 + 0.2*1 + 0.15*1 + 0.15*1 = 1 → 100
if s := ComputeRiskScore(RiskInput{AI: 1, Env: 1, Stage: 1, Uniformity: 1}); s != 100 {
t.Errorf("全 1 应得 100，实际 %.2f", s)
got := ComputeRiskScore(RiskInput{AI: ptr(1), Env: ptr(1), Stage: ptr(1), Uniformity: ptr(1)})
if got.Score != 100 {
t.Errorf("全 1 应得 100，实际 %.2f", got.Score)
}
// 仅 AI 置信度 1：0.5*1 = 0.5 → 50
if s := ComputeRiskScore(RiskInput{AI: 1}); s != 50 {
t.Errorf("仅 AI=1 应得 50，实际 %.2f", s)
if len(got.Missing) != 0 {
t.Errorf("全组件可用时不应有 missing，实际 %v", got.Missing)
}
// 0.5*0.8 + 0.2*0.5 = 0.5
if s := ComputeRiskScore(RiskInput{AI: 0.8, Env: 0.5}); s != 50 {
t.Errorf("0.8/0.5 应得 50，实际 %.2f", s)
if got.Components["aiAbnormalProbability"] == nil || got.Components["uniformity"] == nil {
t.Errorf("全组件可用时 components 不应为 null: %v", got.Components)
}
}
func TestComputeRiskScoreNormalizesMissingComponents(t *testing.T) {
got := ComputeRiskScore(RiskInput{AI: ptr(1)})
if got.Score != 100 {
t.Errorf("仅 AI=1 归一化后应得 100，实际 %.2f", got.Score)
}
if len(got.Missing) != 3 {
t.Errorf("missing 应为 environment/stage/uniformity，实际 %v", got.Missing)
}
if got.Components["environment"] != nil {
t.Error("缺失 environment 应序列化为 null")
}
}
func TestHealthyHighConfidenceDoesNotIncreaseRisk(t *testing.T) {
got := AbnormalProbability([]AIDetection{{ClassName: "healthy", Confidence: .95}})
if got != 0 {
t.Fatalf("healthy 高置信度不应产生异常概率，实际 %v", got)
}
assessment := ComputeRiskScore(RiskInput{AI: ptr(got)})
if assessment.Score != 0 {
t.Fatalf("healthy 高置信度风险分应为 0，实际 %.2f", assessment.Score)
}
}
func TestSickHighConfidenceIncreasesRisk(t *testing.T) {
got := AbnormalProbability([]AIDetection{{ClassName: "sick", Confidence: .9}})
if got != .9 {
t.Fatalf("sick 高置信度异常概率应为 0.9，实际 %v", got)
}
assessment := ComputeRiskScore(RiskInput{AI: ptr(got)})
if assessment.Score != 90 {
t.Fatalf("仅 AI=0.9 归一化后风险分应为 90，实际 %.2f", assessment.Score)
}
}
func TestAbnormalProbabilityIgnoresUnknown(t *testing.T) {
if got := AbnormalProbability([]AIDetection{{ClassName: "unknown", Confidence: .9}}); got != 0 {
t.Errorf("unknown 不应贡献异常概率，实际 %v", got)
}
}
func TestComputeRiskScoreMissingAll(t *testing.T) {
got := ComputeRiskScore(RiskInput{})
if got.Score != 0 {
t.Errorf("无任何组件时分数应为 0，实际 %.2f", got.Score)
}
if got.Confidence != "unknown" {
t.Errorf("无 AI 组件时 confidence 应为 unknown，实际 %s", got.Confidence)
}
if len(got.Missing) != 4 {
t.Errorf("missing 应为 4 项，实际 %v", got.Missing)
}
}
func TestComputeRiskScoreClamps(t *testing.T) {
if s := ComputeRiskScore(RiskInput{AI: 2, Env: 2, Stage: 2, Uniformity: 2}); s > 100 {
t.Errorf("应钳制到 100，实际 %.2f", s)
got := ComputeRiskScore(RiskInput{AI: ptr(2), Env: ptr(2), Stage: ptr(2), Uniformity: ptr(2)})
if got.Score > 100 {
t.Errorf("应钳制到 100，实际 %.2f", got.Score)
}
if s := ComputeRiskScore(RiskInput{AI: -1}); s < 0 {
t.Errorf("应钳制到 0，实际 %.2f", s)
if got := ComputeRiskScore(RiskInput{AI: ptr(-1)}).Score; got < 0 {
t.Errorf("应钳制到 0，实际 %.2f", got)
}
}
func TestRiskConfidenceLowMediumUnknown(t *testing.T) {
if got := RiskConfidence(RiskInput{}); got != "unknown" {
t.Errorf("无 AI 应为 unknown，实际 %s", got)
}
if got := RiskConfidence(RiskInput{AI: ptr(0.2)}); got != "low" {
t.Errorf("低异常概率应为 low，实际 %s", got)
}
if got := RiskConfidence(RiskInput{AI: ptr(0.9)}); got != "medium" {
t.Errorf("高异常概率当前最多应为 medium，实际 %s", got)
}
}
func TestComputeRiskScoreBoundaryUsesWeightNormalization(t *testing.T) {
// 0.5*0.8 + 0.2*0.5 的可用权重为 0.7：0.5/0.7 = 71.43
got := ComputeRiskScore(RiskInput{AI: ptr(0.8), Env: ptr(0.5)})
want := 50.0 / 0.7
if math.Abs(got.Score-want) > 0.01 {
t.Errorf("归一化应得 %.2f，实际 %.2f", want, got.Score)
}
}
func TestRiskLevelBoundaries(t *testing.T) {
cases := map[float64]string{
0: "green",
30: "green",
0: "green",
30: "green",
30.5: "yellow",
60: "yellow",
61: "orange",
80: "orange",
81: "red",
100: "red",
60: "yellow",
61: "orange",
80: "orange",
81: "red",
100: "red",
}
for score, want := range cases {
if got := RiskLevel(score); got != want {
@@ -63,19 +140,19 @@ func TestStageCoefficientMapping(t *testing.T) {
func TestEnvCoefficientRules(t *testing.T) {
// 湿度 >=80 → 高（真菌病）
if c := EnvCoefficient(f(25), f(85)); c < 0.7 {
if c := EnvCoefficient(ptr(25), ptr(85)); c < 0.7 {
t.Errorf("湿度 85 应 ≥0.7，实际 %.2f", c)
}
// 湿度 75-80 → 中
if c := EnvCoefficient(f(25), f(78)); c < 0.3 {
if c := EnvCoefficient(ptr(25), ptr(78)); c < 0.3 {
t.Errorf("湿度 78 应 ≥0.3，实际 %.2f", c)
}
// 温度突变 >30 → 中（核型多角体病诱发）
if c := EnvCoefficient(f(32), f(60)); c < 0.3 {
if c := EnvCoefficient(ptr(32), ptr(60)); c < 0.3 {
t.Errorf("温度 32 应 ≥0.3，实际 %.2f", c)
}
// 舒适环境 → 0
if c := EnvCoefficient(f(25), f(60)); c != 0 {
if c := EnvCoefficient(ptr(25), ptr(60)); c != 0 {
t.Errorf("舒适环境应为 0，实际 %.2f", c)
}
// 缺数据 → 0