LLM 微调实战：SFT、LoRA、QLoRA 与评测

W' = W + scale × B × A

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"strings"
)

type Record struct {
	RecordID string `json:"record_id"`
	GroupID  string `json:"group_id"`
	Split    string `json:"split"`
	Source   string `json:"source"`
	License  string `json:"license"`
	Prompt   string `json:"prompt"`
	Response string `json:"response"`
}

func validateJSONL(reader io.Reader) (int, error) {
	scanner := bufio.NewScanner(reader)
	scanner.Buffer(make([]byte, 64*1024), 4*1024*1024)
	seenRecords := map[string]bool{}
	groupSplits := map[string]string{}
	count := 0

	for scanner.Scan() {
		count++
		var record Record
		if err := json.Unmarshal(scanner.Bytes(), &record); err != nil {
			return 0, fmt.Errorf("line %d: %w", count, err)
		}
		if record.RecordID == "" || record.GroupID == "" || record.Source == "" ||
			record.License == "" || strings.TrimSpace(record.Prompt) == "" ||
			strings.TrimSpace(record.Response) == "" {
			return 0, fmt.Errorf("line %d: missing content or provenance", count)
		}
		if seenRecords[record.RecordID] {
			return 0, fmt.Errorf("line %d: duplicate record_id", count)
		}
		if split, ok := groupSplits[record.GroupID]; ok && split != record.Split {
			return 0, fmt.Errorf("line %d: group leaks across splits", count)
		}
		if record.Split != "train" && record.Split != "validation" && record.Split != "test" {
			return 0, fmt.Errorf("line %d: invalid split", count)
		}
		seenRecords[record.RecordID] = true
		groupSplits[record.GroupID] = record.Split
	}
	if err := scanner.Err(); err != nil {
		return 0, err
	}
	if count == 0 {
		return 0, errors.New("empty_dataset")
	}
	return count, nil
}

func main() {
	input := `{"record_id":"r1","group_id":"g1","split":"train","source":"reviewed","license":"approved","prompt":"Classify A","response":"alpha"}
{"record_id":"r2","group_id":"g2","split":"test","source":"reviewed","license":"approved","prompt":"Classify B","response":"beta"}`
	count, err := validateJSONL(strings.NewReader(input))
	fmt.Printf("records=%d err=%v\n", count, err)
}

// Output: records=2 err=<nil>

run:
  objective: sft
  base_model_revision: immutable-commit
  tokenizer_revision: immutable-commit
  chat_template_sha256: sha256-of-template
  dataset_revision: sha256-of-split-manifest
  framework_lock_sha256: sha256-of-lockfile
  seed_policy: [11, 29, 47]
trainable_surface:
  method: lora
  target_modules: reviewed-list
  rank: measured-candidate
precision:
  weight_storage: declared
  compute: declared
  optimizer_state: declared
evaluation:
  frozen_suite_revision: immutable-commit
  baseline_model_revision: immutable-commit
  release_policy_revision: policy-17

有效 batch = 设备数 × 每设备微批量 × 累积步数

package main

import (
	"fmt"
	"strings"
)

func normalize(value string) string {
	return strings.ToLower(strings.Join(strings.Fields(value), " "))
}

func exactMatchRate(predictions, references []string) (float64, error) {
	if len(predictions) == 0 || len(predictions) != len(references) {
		return 0, fmt.Errorf("predictions and references must have equal non-zero length")
	}
	matches := 0
	for index := range predictions {
		if normalize(predictions[index]) == normalize(references[index]) {
			matches++
		}
	}
	return float64(matches) / float64(len(references)), nil
}

func main() {
	rate, err := exactMatchRate(
		[]string{"ALPHA", "beta value", "wrong"},
		[]string{"alpha", "beta   value", "gamma"},
	)
	fmt.Printf("rate=%.2f err=%v\n", rate, err)
}

// Output: rate=0.67 err=<nil>