openfluke.Explore the code

Cameral cookbook

04 — CamKit / LRs / Rotate / DNA / Dream

Open original example ↗Recorded results · not a live execution

When: schedules, plasticity, replay, speciation
Where: SetBranchLRs / SetRotateSchedule / SetCamKit / DreamPulse
Why: sleep cycles, soft freeze, DNA push/pull, offline consolidation

go run ./04_kit

Exits non-zero if any proof fails (PASS / FAIL lines).

Live output

=== 04_kit — prove LRs / rotate / DNA / dream ===
  PASS  BranchLRs_1|0  cam0 Δ=0.009794 cam1 Δ=0
  PASS  Rotate_slot0  first 5: cam0 Δ=0.002567 cam1 Δ=0
  PASS  Rotate_slot1  next 5: cam0 Δ=0 cam1 Δ=0.002486
  PASS  DNAReg_diversify  diversify cos 0.8446 → -0.8649
  PASS  DNAReg_attract  attract cos 0.3717 → 0.9994
  PASS  DreamPulse  replay avgLoss=0.0012 moved cam0 Δ=0.0009936
  PASS  RefreshMetrics  modes=[NormalBP Freeze] plast=[0.000660944211525738 0]

all CamKit proofs passed

Why these PASS lines prove it

Proof Assertion Why
BranchLRs 1|0 cam1 Δ=0 LR×0 = soft freeze
Rotate_slot0/1 only cam0 then only cam1 moves Sleep schedule flips plasticity
DNAReg_diversify cos 0.84 → negative Push away from mean
DNAReg_attract cos 0.37 → ~1 Pull toward mean
DreamPulse replay loss>0 and ΔW>0 Buffer replay moves weights
RefreshMetrics modes show Freeze, plast[1]=0 Meter matches reality

main.go

Download source ↓
package main

import (
	"fmt"

	"github.com/openfluke/example/cam/internal/harness"
	"github.com/openfluke/welvet/core"
	"github.com/openfluke/welvet/layers/parallel"
)

func main() {
	harness.Banner("04_kit — prove LRs / rotate / DNA / dream")
	x, y := harness.ToyXY(8, 4)

	proveBranchLR(x, y)
	proveRotate(x, y)
	proveDNA(x, y)
	proveDream(x, y)
	proveMetrics(x, y)
	fmt.Println("\nall CamKit proofs passed")
}

func proveBranchLR(x, y *core.Tensor[float32]) {
	para, _ := harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	para.SetBranchModes(parallel.ModeNormalBP, parallel.ModeNormalBP)
	para.SetBranchLRs(1.0, 0.0)
	w0, w1 := harness.DenseWeights(para, 0), harness.DenseWeights(para, 1)
	_, _ = harness.TrainN(para, x, y, 20, 0.1)
	d0 := harness.WeightMaxDiff(w0, harness.DenseWeights(para, 0))
	d1 := harness.WeightMaxDiff(w1, harness.DenseWeights(para, 1))
	harness.Requiref("BranchLRs_1|0", d0 > 1e-4 && d1 < 1e-7, "cam0 Δ=%.4g cam1 Δ=%.4g", d0, d1)
}

func proveRotate(x, y *core.Tensor[float32]) {
	para, _ := harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	para.SetRotateSchedule([][]parallel.TrainMode{
		{parallel.ModeNormalBP, parallel.ModeFreeze},
		{parallel.ModeFreeze, parallel.ModeNormalBP},
	}, 5)

	// Slot 0: only cam0 should move
	w0, w1 := harness.DenseWeights(para, 0), harness.DenseWeights(para, 1)
	for i := 0; i < 5; i++ {
		_, _ = parallel.TrainMSE(para, x, y, parallel.ModeNormalBP, 0.1)
		para.AdvanceRotate()
	}
	d0a := harness.WeightMaxDiff(w0, harness.DenseWeights(para, 0))
	d1a := harness.WeightMaxDiff(w1, harness.DenseWeights(para, 1))

	// Now on slot 1 after 5 advances — next 5 steps only cam1 moves
	w0, w1 = harness.DenseWeights(para, 0), harness.DenseWeights(para, 1)
	for i := 0; i < 5; i++ {
		_, _ = parallel.TrainMSE(para, x, y, parallel.ModeNormalBP, 0.1)
		para.AdvanceRotate()
	}
	d0b := harness.WeightMaxDiff(w0, harness.DenseWeights(para, 0))
	d1b := harness.WeightMaxDiff(w1, harness.DenseWeights(para, 1))

	// TrainMSE also calls AdvanceRotate — careful. We manually AdvanceRotate after each
	// TrainMSE which double-advances if TrainMSE already advances. Looking at TrainMSE —
	// it calls AdvanceRotate at end. So our loop double-counts!
	// Fix: only use TrainMSE without extra Advance, period=5, run 5 then snapshot.
	_ = d0a
	_ = d1a
	_ = d0b
	_ = d1b

	// Cleaner redo:
	para, _ = harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	para.SetRotateSchedule([][]parallel.TrainMode{
		{parallel.ModeNormalBP, parallel.ModeFreeze},
		{parallel.ModeFreeze, parallel.ModeNormalBP},
	}, 5)
	w0, w1 = harness.DenseWeights(para, 0), harness.DenseWeights(para, 1)
	_, _ = harness.TrainN(para, x, y, 5, 0.1) // TrainMSE advances rotate each sample
	d0a = harness.WeightMaxDiff(w0, harness.DenseWeights(para, 0))
	d1a = harness.WeightMaxDiff(w1, harness.DenseWeights(para, 1))
	w0, w1 = harness.DenseWeights(para, 0), harness.DenseWeights(para, 1)
	_, _ = harness.TrainN(para, x, y, 5, 0.1)
	d0b = harness.WeightMaxDiff(w0, harness.DenseWeights(para, 0))
	d1b = harness.WeightMaxDiff(w1, harness.DenseWeights(para, 1))

	harness.Requiref("Rotate_slot0", d0a > 1e-4 && d1a < 1e-7,
		"first 5: cam0 Δ=%.4g cam1 Δ=%.4g", d0a, d1a)
	harness.Requiref("Rotate_slot1", d0b < 1e-7 && d1b > 1e-4,
		"next 5: cam0 Δ=%.4g cam1 Δ=%.4g", d0b, d1b)
}

func proveDNA(x, y *core.Tensor[float32]) {
	// Diversify: start mid-close after soft sync, DNAReg>0 should lower cos.
	para, _ := harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	para.SetCamSync(parallel.CamSyncConfig{Enabled: true, Alpha: 0.5, When: parallel.SyncManual})
	_ = para.SyncNow()
	cosMid := harness.Cos01(para)
	para.SetCamKit(parallel.CamKit{DNAReg: 0.5})
	para.SetBranchModes(parallel.ModeNormalBP, parallel.ModeNormalBP)
	// applyDNAReg runs inside trainParallelMixed — need mixed modes / train
	_, _ = harness.TrainN(para, x, y, 5, 0.01)
	cosDiv := harness.Cos01(para)
	harness.Requiref("DNAReg_diversify", cosDiv < cosMid-0.01,
		"diversify cos %.4f → %.4f", cosMid, cosDiv)

	// Attract: diverge hard, DNAReg<0 should raise cos.
	para, _ = harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	cosLo := harness.Cos01(para)
	para.SetCamKit(parallel.CamKit{DNAReg: -0.5})
	para.SetBranchModes(parallel.ModeNormalBP, parallel.ModeNormalBP)
	_, _ = harness.TrainN(para, x, y, 5, 0.01)
	cosHi := harness.Cos01(para)
	harness.Requiref("DNAReg_attract", cosHi > cosLo+0.05,
		"attract cos %.4f → %.4f", cosLo, cosHi)
}

func proveDream(x, y *core.Tensor[float32]) {
	para, _ := harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	para.SetBranchModes(parallel.ModeNormalBP, parallel.ModeFreeze)
	para.SetCamKit(parallel.CamKit{Dream: &parallel.DreamBuffer{Cap: 64}})
	_, _ = harness.TrainN(para, x, y, 8, 0.08)
	w0 := harness.DenseWeights(para, 0)
	avg, err := para.DreamPulse(4, parallel.ModeNormalBP, 0.05)
	if err != nil {
		panic(err)
	}
	d0 := harness.WeightMaxDiff(w0, harness.DenseWeights(para, 0))
	harness.Requiref("DreamPulse", avg > 0 && d0 > 1e-5,
		"replay avgLoss=%.4f moved cam0 Δ=%.4g", avg, d0)
}

func proveMetrics(x, y *core.Tensor[float32]) {
	para, _ := harness.DenseTwin(8, 4, parallel.CombineAvg)
	_ = harness.DivergeCams(para)
	para.SetBranchModes(parallel.ModeNormalBP, parallel.ModeFreeze)
	_, _ = harness.TrainN(para, x, y, 10, 0.1)
	m := para.RefreshMetrics()
	harness.Requiref("RefreshMetrics",
		len(m.ActiveModes) == 2 && m.ActiveModes[1] == "Freeze" && len(m.Plasticity) == 2 && m.Plasticity[1] == 0,
		"modes=%v plast=%v", m.ActiveModes, m.Plasticity)
}
← Back to the example library