AI 图像理解工程：生产级 OCR、文档解析与 VQA

{
  "page": 2,
  "page_size": {"width": 2480, "height": 3508},
  "polygon_norm": [[0.071, 0.181], [0.314, 0.176], [0.317, 0.204], [0.074, 0.208]],
  "source_span_id": "ocr-p2-s184",
  "transform_version": "deskew-v3"
}

{
  "evidence_id": "ev-0184",
  "document_sha256": "65b87d0f...",
  "page": 2,
  "kind": "ocr_span",
  "text": "Total due USD 1,248.00",
  "bbox_norm": [0.621, 0.744, 0.913, 0.781],
  "artifact_version": "ocr-v17",
  "transform_version": "deskew-v3"
}

{
  "field": "total_amount",
  "raw_value": "USD 1,248.00",
  "normalized_value": 1248.0,
  "calibrated_score": 0.973,
  "evidence_refs": ["ev-0184"],
  "normalizer_version": "money-v4",
  "validation_refs": ["currency-iso4217", "invoice-total-v2"]
}

{
  "answer": "Operating margin increased from 14% to 18%.",
  "answer_type": "comparison",
  "evidence_refs": ["chart-p7-series-a", "chart-p7-series-b"],
  "calibrated_score": 0.91,
  "abstained": false,
  "limitations": ["Values were read from labeled bars, not the source data table."]
}

sha256(source_bytes) + task_schema_version + pipeline_version

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"math"
	"sort"
)

type Box struct {
	X1 float64
	Y1 float64
	X2 float64
	Y2 float64
}

type Evidence struct {
	ID       string
	Page     int
	Kind     string
	Box      Box
	Artifact string
}

type Field struct {
	Value           string
	CalibratedScore float64
	EvidenceRefs    []string
}

type Invariant struct {
	Name   string
	Passed bool
}

type Extraction struct {
	SourceSHA256 string
	Fields       map[string]Field
	Evidence     []Evidence
	Invariants   []Invariant
}

type GateConfig struct {
	RequiredFields     []string
	AutomaticThreshold float64
	ReviewThreshold    float64
}

type GateResult struct {
	Route   string
	Reasons []string
}

func digest(data []byte) string {
	sum := sha256.Sum256(data)
	return hex.EncodeToString(sum[:])
}

func validDigest(value string) bool {
	decoded, err := hex.DecodeString(value)
	return err == nil && len(decoded) == sha256.Size && value == hex.EncodeToString(decoded)
}

func validBox(box Box) bool {
	return box.X1 >= 0 && box.Y1 >= 0 &&
		box.X2 <= 1 && box.Y2 <= 1 &&
		box.X1 < box.X2 && box.Y1 < box.Y2
}

func evaluate(source []byte, extraction Extraction, config GateConfig) GateResult {
	hardFailures := make([]string, 0)
	reviewReasons := make([]string, 0)

	if !validDigest(extraction.SourceSHA256) || extraction.SourceSHA256 != digest(source) {
		hardFailures = append(hardFailures, "source hash mismatch")
	}

	evidenceByID := make(map[string]Evidence, len(extraction.Evidence))
	for _, item := range extraction.Evidence {
		if item.ID == "" || item.Page < 1 || item.Artifact == "" || !validBox(item.Box) {
			hardFailures = append(hardFailures, "invalid evidence: "+item.ID)
			continue
		}
		if _, exists := evidenceByID[item.ID]; exists {
			hardFailures = append(hardFailures, "duplicate evidence: "+item.ID)
			continue
		}
		evidenceByID[item.ID] = item
	}

	for _, name := range config.RequiredFields {
		field, exists := extraction.Fields[name]
		if !exists || field.Value == "" {
			hardFailures = append(hardFailures, "missing required field: "+name)
			continue
		}
		if math.IsNaN(field.CalibratedScore) ||
			math.IsInf(field.CalibratedScore, 0) ||
			field.CalibratedScore < 0 ||
			field.CalibratedScore > 1 {
			hardFailures = append(hardFailures, "invalid calibrated score: "+name)
		}
		if len(field.EvidenceRefs) == 0 {
			hardFailures = append(hardFailures, "field has no evidence: "+name)
		}
		for _, ref := range field.EvidenceRefs {
			if _, exists := evidenceByID[ref]; !exists {
				hardFailures = append(hardFailures, "unresolved evidence: "+name+" -> "+ref)
			}
		}
		if field.CalibratedScore < config.ReviewThreshold {
			hardFailures = append(hardFailures, "score below review threshold: "+name)
		} else if field.CalibratedScore < config.AutomaticThreshold {
			reviewReasons = append(reviewReasons, "score requires review: "+name)
		}
	}

	for _, invariant := range extraction.Invariants {
		if !invariant.Passed {
			hardFailures = append(hardFailures, "failed invariant: "+invariant.Name)
		}
	}

	if len(hardFailures) > 0 {
		sort.Strings(hardFailures)
		return GateResult{Route: "reject", Reasons: hardFailures}
	}
	if len(reviewReasons) > 0 {
		sort.Strings(reviewReasons)
		return GateResult{Route: "review", Reasons: reviewReasons}
	}
	return GateResult{Route: "automatic"}
}

func validateConfig(config GateConfig) error {
	if math.IsNaN(config.ReviewThreshold) ||
		math.IsNaN(config.AutomaticThreshold) ||
		math.IsInf(config.ReviewThreshold, 0) ||
		math.IsInf(config.AutomaticThreshold, 0) ||
		config.ReviewThreshold < 0 ||
		config.ReviewThreshold > 1 ||
		config.AutomaticThreshold < 0 ||
		config.AutomaticThreshold > 1 ||
		config.ReviewThreshold >= config.AutomaticThreshold {
		return errors.New("invalid gate thresholds")
	}
	return nil
}

func main() {
	source := []byte("fixture-page-v1")
	config := GateConfig{
		RequiredFields:     []string{"invoice_number", "currency", "total_amount"},
		AutomaticThreshold: 0.92,
		ReviewThreshold:    0.70,
	}
	if err := validateConfig(config); err != nil {
		panic(err)
	}

	extraction := Extraction{
		SourceSHA256: digest(source),
		Fields: map[string]Field{
			"invoice_number": {
				Value:           "INV-1042",
				CalibratedScore: 0.98,
				EvidenceRefs:    []string{"ev-invoice"},
			},
			"currency": {
				Value:           "USD",
				CalibratedScore: 0.96,
				EvidenceRefs:    []string{"ev-total"},
			},
			"total_amount": {
				Value:           "1248.00",
				CalibratedScore: 0.94,
				EvidenceRefs:    []string{"ev-total"},
			},
		},
		Evidence: []Evidence{
			{
				ID:       "ev-invoice",
				Page:     1,
				Kind:     "ocr_span",
				Box:      Box{X1: 0.12, Y1: 0.18, X2: 0.31, Y2: 0.21},
				Artifact: "ocr-v17",
			},
			{
				ID:       "ev-total",
				Page:     1,
				Kind:     "table_cell",
				Box:      Box{X1: 0.62, Y1: 0.74, X2: 0.91, Y2: 0.78},
				Artifact: "table-v9",
			},
		},
		Invariants: []Invariant{
			{Name: "subtotal_plus_tax_equals_total", Passed: true},
			{Name: "currency_matches_total_symbol", Passed: true},
		},
	}

	result := evaluate(source, extraction, config)
	fmt.Printf("route=%s reasons=%v\n", result.Route, result.Reasons)
}

route=automatic reasons=[]