generated from mathias/template-go-web
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 mathias
|
50635cd80e | ||
|
mathias
|
a0d180e37d |
@@ -28,9 +28,3 @@ go.work.sum
|
||||
# Project-specific
|
||||
bin/
|
||||
*.templ.go
|
||||
|
||||
# python venv (autoresearch loop)
|
||||
.venv/
|
||||
|
||||
# downloaded + processed market data (track via DVC/MinIO, #10 — not git)
|
||||
data/
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
# Autoresearch STATUS
|
||||
|
||||
| iter | val_vol_r2 | delta | action | secs | gpu | change |
|
||||
|------|-----------|-------|--------|------|-----|--------|
|
||||
| 1 | 0.3749 | +0.0928 | KEEP | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter1 |
|
||||
| 1 | 0.3011 | +0.0776 | KEEP | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter1 |
|
||||
| 2 | 0.3032 | +0.0021 | KEEP | 2s | gpu=0% vram=10054/12227MiB temp=35°C | iter2 |
|
||||
| 1 | 0.2759 | -0.0273 | revert | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter1 |
|
||||
| 2 | 0.3442 | +0.0410 | KEEP | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter2 |
|
||||
| 3 | 0.3371 | -0.0071 | revert | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter3 |
|
||||
| 4 | 0.3143 | -0.0299 | revert | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter4 |
|
||||
| 5 | 0.3355 | -0.0087 | revert | 2s | gpu=0% vram=10054/12227MiB temp=34°C | iter5 |
|
||||
| 6 | 0.2377 | -0.1065 | revert | 2s | gpu=0% vram=10054/12227MiB temp=35°C | iter6 |
|
||||
| 1 | -0.1247 | +0.0296 | KEEP | 4s | gpu=0% vram=10054/12227MiB temp=35°C | iter1 |
|
||||
| 2 | -0.1203 | +0.0044 | KEEP | 4s | gpu=0% vram=10054/12227MiB temp=35°C | iter2 |
|
||||
| 3 | -0.0716 | +0.0487 | KEEP | 4s | gpu=0% vram=10054/12227MiB temp=36°C | iter3 |
|
||||
| 4 | 0.0590 | +0.1306 | KEEP | 5s | gpu=0% vram=10054/12227MiB temp=36°C | iter4 |
|
||||
| 5 | 0.0599 | +0.0009 | KEEP | 5s | gpu=0% vram=10054/12227MiB temp=37°C | iter5 |
|
||||
+3
-15
@@ -5,28 +5,16 @@ tasks:
|
||||
desc: Run templ generate
|
||||
cmds: [templ generate]
|
||||
build:
|
||||
desc: Build all binaries
|
||||
desc: Build the binary
|
||||
deps: [generate]
|
||||
cmds:
|
||||
- go build -o bin/jepa-fx-risk ./cmd/jepa-fx-risk
|
||||
- go build -o bin/eval ./cmd/eval
|
||||
cmds: [go build -o bin/hostexecutor ./cmd/hostexecutor]
|
||||
run:
|
||||
deps: [build]
|
||||
cmds: [./bin/jepa-fx-risk]
|
||||
cmds: [./bin/hostexecutor]
|
||||
test:
|
||||
desc: Run all tests
|
||||
deps: [generate]
|
||||
cmds: [go test ./... -race]
|
||||
|
||||
eval:probe:
|
||||
desc: "Run linear-probe (val_vol_r2) on embeddings from metrics.json"
|
||||
cmds: [./bin/eval -metric probe]
|
||||
eval:silhouette:
|
||||
desc: "Run silhouette on embeddings vs binary HV labels"
|
||||
cmds: [./bin/eval -metric silhouette]
|
||||
eval:collapse:
|
||||
desc: "Run effective-rank collapse diagnostic"
|
||||
cmds: [./bin/eval -metric erank]
|
||||
lint:
|
||||
cmds: [golangci-lint run ./...]
|
||||
check:
|
||||
|
||||
@@ -1,118 +0,0 @@
|
||||
// cmd/eval — CLI driver for the jepa-fx-risk evaluation harness.
|
||||
// Reads embeddings from a parquet/npy-style JSON export (embeddings.json)
|
||||
// and targets from eurusd_daily.parquet, then runs the requested metric.
|
||||
//
|
||||
// ./bin/eval -metric probe|silhouette|erank [-emb embeddings.json]
|
||||
//
|
||||
// embeddings.json format: {"embeddings": [[...], ...], "dates": ["2022-01-03", ...]}
|
||||
// Generated by train.py when run with EXPORT_EMBEDDINGS=1.
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"math"
|
||||
"os"
|
||||
|
||||
"gitea.d-ma.be/mathias/jepa-fx-risk/internal/eval"
|
||||
)
|
||||
|
||||
func main() {
|
||||
metric := flag.String("metric", "probe", "probe | silhouette | erank")
|
||||
embFile := flag.String("emb", "embeddings.json", "path to embeddings JSON")
|
||||
flag.Parse()
|
||||
|
||||
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
||||
|
||||
emb, labels, y, err := loadEmbeddings(*embFile)
|
||||
if err != nil {
|
||||
log.Error("load embeddings", "err", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
log.Info("loaded", "n", len(emb), "dim", len(emb[0]), "metric", *metric)
|
||||
|
||||
switch *metric {
|
||||
case "probe":
|
||||
r2 := eval.LinearProbe(emb, y, 1e-3)
|
||||
fmt.Printf(`{"metric":"val_vol_r2","value":%.6f}`+"\n", r2)
|
||||
log.Info("linear probe", "val_vol_r2", fmt.Sprintf("%.4f", r2))
|
||||
case "silhouette":
|
||||
if labels == nil {
|
||||
log.Error("silhouette requires HV labels in embeddings.json")
|
||||
os.Exit(1)
|
||||
}
|
||||
sil, err := eval.Silhouette(emb, labels)
|
||||
if err != nil {
|
||||
log.Error("silhouette", "err", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
fmt.Printf(`{"metric":"silhouette","value":%.6f}`+"\n", sil)
|
||||
log.Info("silhouette", "score", fmt.Sprintf("%.4f", sil))
|
||||
case "erank":
|
||||
er := eval.EffectiveRank(emb)
|
||||
fmt.Printf(`{"metric":"effective_rank","value":%.6f}`+"\n", er)
|
||||
log.Info("effective rank", "erank", fmt.Sprintf("%.2f", er))
|
||||
default:
|
||||
log.Error("unknown metric", "metric", *metric)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
type embJSON struct {
|
||||
Embeddings [][]float64 `json:"embeddings"`
|
||||
Dates []string `json:"dates"`
|
||||
RealizedVol []float64 `json:"realized_vol"`
|
||||
HVLabel []int `json:"hv_label"`
|
||||
}
|
||||
|
||||
func loadEmbeddings(path string) (emb [][]float64, labels []int, y []float64, err error) {
|
||||
f, err := os.Open(path)
|
||||
if err != nil {
|
||||
return nil, nil, nil, fmt.Errorf("open %s: %w", path, err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
|
||||
var d embJSON
|
||||
if err := json.NewDecoder(f).Decode(&d); err != nil {
|
||||
return nil, nil, nil, fmt.Errorf("decode: %w", err)
|
||||
}
|
||||
if len(d.Embeddings) == 0 {
|
||||
return nil, nil, nil, fmt.Errorf("empty embeddings in %s", path)
|
||||
}
|
||||
|
||||
// standardise embeddings (zero mean, unit std) per dimension
|
||||
n, dim := len(d.Embeddings), len(d.Embeddings[0])
|
||||
mu := make([]float64, dim)
|
||||
for _, row := range d.Embeddings {
|
||||
for j, v := range row {
|
||||
mu[j] += v
|
||||
}
|
||||
}
|
||||
for j := range mu {
|
||||
mu[j] /= float64(n)
|
||||
}
|
||||
sd := make([]float64, dim)
|
||||
for _, row := range d.Embeddings {
|
||||
for j, v := range row {
|
||||
diff := v - mu[j]
|
||||
sd[j] += diff * diff
|
||||
}
|
||||
}
|
||||
for j := range sd {
|
||||
sd[j] = math.Sqrt(sd[j]/float64(n)) + 1e-8
|
||||
}
|
||||
norm := make([][]float64, n)
|
||||
for i, row := range d.Embeddings {
|
||||
norm[i] = make([]float64, dim)
|
||||
for j, v := range row {
|
||||
norm[i][j] = (v - mu[j]) / sd[j]
|
||||
}
|
||||
}
|
||||
|
||||
if len(d.HVLabel) > 0 {
|
||||
labels = d.HVLabel
|
||||
}
|
||||
return norm, labels, d.RealizedVol, nil
|
||||
}
|
||||
@@ -5,7 +5,7 @@ import (
|
||||
"net/http"
|
||||
"os"
|
||||
|
||||
"gitea.d-ma.be/mathias/jepa-fx-risk/internal/web"
|
||||
"gitea.d-ma.be/mathias/hostexecutor/internal/web"
|
||||
)
|
||||
|
||||
func main() {
|
||||
@@ -1,5 +1,7 @@
|
||||
module gitea.d-ma.be/mathias/jepa-fx-risk
|
||||
module gitea.d-ma.be/mathias/hostexecutor
|
||||
|
||||
go 1.26
|
||||
|
||||
require github.com/a-h/templ v0.3.1020
|
||||
require (
|
||||
github.com/a-h/templ v0.2.778
|
||||
)
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
github.com/a-h/templ v0.3.1020 h1:ypAT/L5ySWEnZ6Zft/5yfoWXYYkhFNvEFOeeqecg4tw=
|
||||
github.com/a-h/templ v0.3.1020/go.mod h1:A2DlK61v+K+NRoGnhmYbNYVmtYHcFO5/AisMvBdDxTM=
|
||||
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
|
||||
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
|
||||
@@ -1,331 +0,0 @@
|
||||
// Package eval implements the Go evaluation harness for jepa-fx-risk (#4).
|
||||
// Three diagnostics on frozen embeddings exported from train.py:
|
||||
// - LinearProbe — val_vol_r2: OOS R² of a ridge probe predicting next-day realized vol
|
||||
// - Silhouette — mean silhouette score of embeddings vs a binary label (HV regime)
|
||||
// - EffectiveRank — Roy's effective rank: exp(H(σ²)) where H is entropy of normalised singular values
|
||||
package eval
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"math"
|
||||
)
|
||||
|
||||
// LinearProbe fits a ridge regression (closed-form) on (emb, y) with regularisation λ
|
||||
// and returns R² on the same data. Call with train embeddings; probe on held-out by
|
||||
// splitting before calling.
|
||||
//
|
||||
// emb[i] is the embedding vector for sample i; y[i] is the scalar target.
|
||||
func LinearProbe(emb [][]float64, y []float64, lambda float64) float64 {
|
||||
n := len(emb)
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
d := len(emb[0])
|
||||
|
||||
// Build augmented design matrix A = [emb | 1] (n × d+1)
|
||||
A := make([][]float64, n)
|
||||
for i, e := range emb {
|
||||
row := make([]float64, d+1)
|
||||
copy(row, e)
|
||||
row[d] = 1.0
|
||||
A[i] = row
|
||||
}
|
||||
|
||||
// Normal equations: (AᵀA + λI) w = Aᵀy (ridge)
|
||||
p := d + 1
|
||||
AtA := make([][]float64, p)
|
||||
for i := range AtA {
|
||||
AtA[i] = make([]float64, p)
|
||||
}
|
||||
Aty := make([]float64, p)
|
||||
|
||||
for i := 0; i < n; i++ {
|
||||
for j := 0; j < p; j++ {
|
||||
Aty[j] += A[i][j] * y[i]
|
||||
for k := 0; k < p; k++ {
|
||||
AtA[j][k] += A[i][j] * A[i][k]
|
||||
}
|
||||
}
|
||||
}
|
||||
for j := 0; j < p; j++ {
|
||||
AtA[j][j] += lambda
|
||||
}
|
||||
|
||||
w := solveCholesky(AtA, Aty)
|
||||
|
||||
// R² = 1 - SS_res / SS_tot
|
||||
yMean := mean(y)
|
||||
var ssRes, ssTot float64
|
||||
for i := 0; i < n; i++ {
|
||||
pred := dot(A[i], w)
|
||||
ssRes += (y[i] - pred) * (y[i] - pred)
|
||||
ssTot += (y[i] - yMean) * (y[i] - yMean)
|
||||
}
|
||||
if ssTot == 0 {
|
||||
return 0
|
||||
}
|
||||
return 1 - ssRes/ssTot
|
||||
}
|
||||
|
||||
// Silhouette returns the mean silhouette coefficient of the embeddings with respect
|
||||
// to the given integer labels. Distances are Euclidean. Returns an error if fewer
|
||||
// than 2 distinct labels are present.
|
||||
func Silhouette(emb [][]float64, labels []int) (float64, error) {
|
||||
n := len(emb)
|
||||
if n == 0 {
|
||||
return 0, errors.New("eval: empty embeddings")
|
||||
}
|
||||
|
||||
// count distinct labels
|
||||
labelSet := map[int]struct{}{}
|
||||
for _, l := range labels {
|
||||
labelSet[l] = struct{}{}
|
||||
}
|
||||
if len(labelSet) < 2 {
|
||||
return 0, errors.New("eval: silhouette requires at least 2 distinct labels")
|
||||
}
|
||||
|
||||
// group indices by label
|
||||
groups := map[int][]int{}
|
||||
for i, l := range labels {
|
||||
groups[l] = append(groups[l], i)
|
||||
}
|
||||
|
||||
var total float64
|
||||
for i := 0; i < n; i++ {
|
||||
li := labels[i]
|
||||
|
||||
// a(i) = mean intra-cluster distance
|
||||
var aSum float64
|
||||
inGroup := groups[li]
|
||||
for _, j := range inGroup {
|
||||
if j != i {
|
||||
aSum += euclidean(emb[i], emb[j])
|
||||
}
|
||||
}
|
||||
var a float64
|
||||
if len(inGroup) > 1 {
|
||||
a = aSum / float64(len(inGroup)-1)
|
||||
}
|
||||
|
||||
// b(i) = min mean inter-cluster distance
|
||||
b := math.MaxFloat64
|
||||
for l, idxs := range groups {
|
||||
if l == li {
|
||||
continue
|
||||
}
|
||||
var dSum float64
|
||||
for _, j := range idxs {
|
||||
dSum += euclidean(emb[i], emb[j])
|
||||
}
|
||||
avg := dSum / float64(len(idxs))
|
||||
if avg < b {
|
||||
b = avg
|
||||
}
|
||||
}
|
||||
|
||||
s := (b - a) / math.Max(a, b)
|
||||
total += s
|
||||
}
|
||||
return total / float64(n), nil
|
||||
}
|
||||
|
||||
// EffectiveRank computes Roy's effective rank of the embedding matrix:
|
||||
// exp(H) where H = -∑ pᵢ log(pᵢ) is the Shannon entropy of the normalised
|
||||
// squared singular values. Returns 1 for a rank-1 matrix and ≈ dim for
|
||||
// a full-rank isotropic matrix.
|
||||
func EffectiveRank(emb [][]float64) float64 {
|
||||
n := len(emb)
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
d := len(emb[0])
|
||||
|
||||
// Compute covariance-like matrix CᵀC where C is mean-centered embedding.
|
||||
mu := make([]float64, d)
|
||||
for _, e := range emb {
|
||||
for j, v := range e {
|
||||
mu[j] += v
|
||||
}
|
||||
}
|
||||
for j := range mu {
|
||||
mu[j] /= float64(n)
|
||||
}
|
||||
|
||||
// C = emb - mu (n × d); compute CᵀC (d × d)
|
||||
CtC := make([][]float64, d)
|
||||
for i := range CtC {
|
||||
CtC[i] = make([]float64, d)
|
||||
}
|
||||
for _, e := range emb {
|
||||
for j := 0; j < d; j++ {
|
||||
cj := e[j] - mu[j]
|
||||
for k := 0; k < d; k++ {
|
||||
CtC[j][k] += cj * (e[k] - mu[k])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Eigenvalues of CᵀC via power iteration approximation isn't great;
|
||||
// use the Frobenius / trace approach: σᵢ² ∝ eigenvalues of CᵀC.
|
||||
// For a pure-Go impl without LAPACK: use the fact that the normalised
|
||||
// squared singular values equal normalised eigenvalues of CᵀC.
|
||||
// Compute them via Jacobi iteration for small d, or use the analytical
|
||||
// formula for 2×2, or use iterative QR for general d.
|
||||
eigs := jacobiEigenvalues(CtC)
|
||||
|
||||
// normalise to sum-1 distribution
|
||||
var sumEig float64
|
||||
for _, v := range eigs {
|
||||
if v > 0 {
|
||||
sumEig += v
|
||||
}
|
||||
}
|
||||
if sumEig == 0 {
|
||||
return 1
|
||||
}
|
||||
var H float64
|
||||
for _, v := range eigs {
|
||||
if v > 0 {
|
||||
p := v / sumEig
|
||||
H -= p * math.Log(p)
|
||||
}
|
||||
}
|
||||
return math.Exp(H)
|
||||
}
|
||||
|
||||
// ── internal helpers ──────────────────────────────────────────────────────────
|
||||
|
||||
func euclidean(a, b []float64) float64 {
|
||||
var s float64
|
||||
for i := range a {
|
||||
d := a[i] - b[i]
|
||||
s += d * d
|
||||
}
|
||||
return math.Sqrt(s)
|
||||
}
|
||||
|
||||
func dot(a, b []float64) float64 {
|
||||
var s float64
|
||||
for i := range a {
|
||||
s += a[i] * b[i]
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func mean(y []float64) float64 {
|
||||
var s float64
|
||||
for _, v := range y {
|
||||
s += v
|
||||
}
|
||||
return s / float64(len(y))
|
||||
}
|
||||
|
||||
// solveCholesky solves Ax = b for symmetric positive-definite A via
|
||||
// Cholesky decomposition. Falls back to pseudo-inverse on failure.
|
||||
func solveCholesky(A [][]float64, b []float64) []float64 {
|
||||
n := len(A)
|
||||
// Cholesky decomposition: A = LLᵀ
|
||||
L := make([][]float64, n)
|
||||
for i := range L {
|
||||
L[i] = make([]float64, n)
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
for j := 0; j <= i; j++ {
|
||||
s := A[i][j]
|
||||
for k := 0; k < j; k++ {
|
||||
s -= L[i][k] * L[j][k]
|
||||
}
|
||||
if i == j {
|
||||
if s <= 0 {
|
||||
s = 1e-12
|
||||
}
|
||||
L[i][j] = math.Sqrt(s)
|
||||
} else {
|
||||
L[i][j] = s / L[j][j]
|
||||
}
|
||||
}
|
||||
}
|
||||
// Forward substitution Ly = b
|
||||
y := make([]float64, n)
|
||||
for i := 0; i < n; i++ {
|
||||
s := b[i]
|
||||
for k := 0; k < i; k++ {
|
||||
s -= L[i][k] * y[k]
|
||||
}
|
||||
y[i] = s / L[i][i]
|
||||
}
|
||||
// Back substitution Lᵀx = y
|
||||
x := make([]float64, n)
|
||||
for i := n - 1; i >= 0; i-- {
|
||||
s := y[i]
|
||||
for k := i + 1; k < n; k++ {
|
||||
s -= L[k][i] * x[k]
|
||||
}
|
||||
x[i] = s / L[i][i]
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
// jacobiEigenvalues returns eigenvalues of a symmetric matrix via Jacobi iteration.
|
||||
func jacobiEigenvalues(A [][]float64) []float64 {
|
||||
n := len(A)
|
||||
// copy
|
||||
a := make([][]float64, n)
|
||||
for i := range a {
|
||||
a[i] = make([]float64, n)
|
||||
copy(a[i], A[i])
|
||||
}
|
||||
|
||||
const maxIter = 100
|
||||
const tol = 1e-10
|
||||
for iter := 0; iter < maxIter; iter++ {
|
||||
// find largest off-diagonal element
|
||||
p, q, amax := 0, 1, 0.0
|
||||
for i := 0; i < n; i++ {
|
||||
for j := i + 1; j < n; j++ {
|
||||
if v := math.Abs(a[i][j]); v > amax {
|
||||
amax = v
|
||||
p, q = i, j
|
||||
}
|
||||
}
|
||||
}
|
||||
if amax < tol {
|
||||
break
|
||||
}
|
||||
// Jacobi rotation
|
||||
theta := 0.5 * math.Atan2(2*a[p][q], a[q][q]-a[p][p])
|
||||
c, s := math.Cos(theta), math.Sin(theta)
|
||||
// apply rotation
|
||||
newA := make([][]float64, n)
|
||||
for i := range newA {
|
||||
newA[i] = make([]float64, n)
|
||||
copy(newA[i], a[i])
|
||||
}
|
||||
app := c*c*a[p][p] + 2*c*s*a[p][q] + s*s*a[q][q]
|
||||
aqq := s*s*a[p][p] - 2*c*s*a[p][q] + c*c*a[q][q]
|
||||
apq := 0.0
|
||||
newA[p][p] = app
|
||||
newA[q][q] = aqq
|
||||
newA[p][q] = apq
|
||||
newA[q][p] = apq
|
||||
for r := 0; r < n; r++ {
|
||||
if r == p || r == q {
|
||||
continue
|
||||
}
|
||||
arp := c*a[r][p] + s*a[r][q]
|
||||
arq := -s*a[r][p] + c*a[r][q]
|
||||
newA[r][p] = arp
|
||||
newA[p][r] = arp
|
||||
newA[r][q] = arq
|
||||
newA[q][r] = arq
|
||||
}
|
||||
a = newA
|
||||
}
|
||||
|
||||
eigs := make([]float64, n)
|
||||
for i := range eigs {
|
||||
eigs[i] = a[i][i]
|
||||
}
|
||||
return eigs
|
||||
}
|
||||
@@ -1,138 +0,0 @@
|
||||
package eval_test
|
||||
|
||||
import (
|
||||
"math"
|
||||
"math/rand"
|
||||
"testing"
|
||||
|
||||
"gitea.d-ma.be/mathias/jepa-fx-risk/internal/eval"
|
||||
)
|
||||
|
||||
func seededRNG(seed int64) *rand.Rand {
|
||||
return rand.New(rand.NewSource(seed))
|
||||
}
|
||||
|
||||
// ── LinearProbe (val_vol_r2) ──────────────────────────────────────────────────
|
||||
|
||||
func TestLinearProbe_Perfect(t *testing.T) {
|
||||
n := 50
|
||||
emb := make([][]float64, n)
|
||||
y := make([]float64, n)
|
||||
for i := range emb {
|
||||
emb[i] = []float64{float64(i)}
|
||||
y[i] = float64(i)
|
||||
}
|
||||
r2 := eval.LinearProbe(emb, y, 1e-3)
|
||||
if r2 < 0.99 {
|
||||
t.Fatalf("perfect predictor: want R²≥0.99, got %.4f", r2)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLinearProbe_ConstantTarget(t *testing.T) {
|
||||
n := 40
|
||||
emb := make([][]float64, n)
|
||||
y := make([]float64, n)
|
||||
for i := range emb {
|
||||
emb[i] = []float64{float64(i), float64(i * i)}
|
||||
y[i] = 3.0
|
||||
}
|
||||
r2 := eval.LinearProbe(emb, y, 1e-3)
|
||||
if r2 > 0.01 {
|
||||
t.Fatalf("constant target: want R²≤0.01, got %.4f", r2)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLinearProbe_NoiseEmbedding(t *testing.T) {
|
||||
rng := seededRNG(42)
|
||||
n := 80
|
||||
emb := make([][]float64, n)
|
||||
y := make([]float64, n)
|
||||
for i := range emb {
|
||||
emb[i] = []float64{rng.NormFloat64(), rng.NormFloat64()}
|
||||
y[i] = float64(i)
|
||||
}
|
||||
r2 := eval.LinearProbe(emb, y, 1e-3)
|
||||
if r2 > 0.10 {
|
||||
t.Fatalf("noise embedding: want R²<0.10, got %.4f", r2)
|
||||
}
|
||||
}
|
||||
|
||||
// ── Silhouette ────────────────────────────────────────────────────────────────
|
||||
|
||||
func TestSilhouette_PerfectClusters(t *testing.T) {
|
||||
emb := make([][]float64, 40)
|
||||
labels := make([]int, 40)
|
||||
for i := range emb {
|
||||
if i < 20 {
|
||||
emb[i] = []float64{0.0, 0.0}
|
||||
labels[i] = 0
|
||||
} else {
|
||||
emb[i] = []float64{1000.0, 1000.0}
|
||||
labels[i] = 1
|
||||
}
|
||||
}
|
||||
sil, err := eval.Silhouette(emb, labels)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if sil < 0.95 {
|
||||
t.Fatalf("perfect clusters: want sil≥0.95, got %.4f", sil)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSilhouette_SingleLabel(t *testing.T) {
|
||||
emb := [][]float64{{1, 2}, {3, 4}, {5, 6}}
|
||||
labels := []int{0, 0, 0}
|
||||
_, err := eval.Silhouette(emb, labels)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for single-label input")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSilhouette_RandomClusters(t *testing.T) {
|
||||
rng := seededRNG(7)
|
||||
n := 60
|
||||
emb := make([][]float64, n)
|
||||
labels := make([]int, n)
|
||||
for i := range emb {
|
||||
emb[i] = []float64{rng.NormFloat64(), rng.NormFloat64()}
|
||||
labels[i] = i % 2
|
||||
}
|
||||
sil, err := eval.Silhouette(emb, labels)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if math.Abs(sil) > 0.30 {
|
||||
t.Fatalf("random clusters: want |sil|≤0.30, got %.4f", sil)
|
||||
}
|
||||
}
|
||||
|
||||
// ── EffectiveRank ─────────────────────────────────────────────────────────────
|
||||
|
||||
func TestEffectiveRank_Rank1(t *testing.T) {
|
||||
emb := make([][]float64, 30)
|
||||
for i := range emb {
|
||||
emb[i] = []float64{1.0, 2.0, 3.0, 4.0}
|
||||
}
|
||||
er := eval.EffectiveRank(emb)
|
||||
if er > 1.5 {
|
||||
t.Fatalf("rank-1 matrix: want erank≤1.5, got %.4f", er)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEffectiveRank_FullRank(t *testing.T) {
|
||||
rng := seededRNG(99)
|
||||
dim := 8
|
||||
emb := make([][]float64, 200)
|
||||
for i := range emb {
|
||||
row := make([]float64, dim)
|
||||
for j := range row {
|
||||
row[j] = rng.NormFloat64()
|
||||
}
|
||||
emb[i] = row
|
||||
}
|
||||
er := eval.EffectiveRank(emb)
|
||||
if er < float64(dim)*0.7 {
|
||||
t.Fatalf("full-rank: want erank≥%.1f, got %.4f", float64(dim)*0.7, er)
|
||||
}
|
||||
}
|
||||
@@ -1,100 +0,0 @@
|
||||
// Code generated by templ - DO NOT EDIT.
|
||||
|
||||
// templ: version: v0.3.1020
|
||||
package web
|
||||
|
||||
//lint:file-ignore SA4006 This context is only used if a nested component is present.
|
||||
|
||||
import "github.com/a-h/templ"
|
||||
import templruntime "github.com/a-h/templ/runtime"
|
||||
|
||||
func Index() templ.Component {
|
||||
return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
|
||||
templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
|
||||
if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
|
||||
return templ_7745c5c3_CtxErr
|
||||
}
|
||||
templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
|
||||
if !templ_7745c5c3_IsBuffer {
|
||||
defer func() {
|
||||
templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
|
||||
if templ_7745c5c3_Err == nil {
|
||||
templ_7745c5c3_Err = templ_7745c5c3_BufErr
|
||||
}
|
||||
}()
|
||||
}
|
||||
ctx = templ.InitializeContext(ctx)
|
||||
templ_7745c5c3_Var1 := templ.GetChildren(ctx)
|
||||
if templ_7745c5c3_Var1 == nil {
|
||||
templ_7745c5c3_Var1 = templ.NopComponent
|
||||
}
|
||||
ctx = templ.ClearChildren(ctx)
|
||||
templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
|
||||
templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
|
||||
templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
|
||||
if !templ_7745c5c3_IsBuffer {
|
||||
defer func() {
|
||||
templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
|
||||
if templ_7745c5c3_Err == nil {
|
||||
templ_7745c5c3_Err = templ_7745c5c3_BufErr
|
||||
}
|
||||
}()
|
||||
}
|
||||
ctx = templ.InitializeContext(ctx)
|
||||
templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 1, "<h1 class=\"text-3xl font-semibold mb-6\">hostexecutor</h1><button hx-get=\"/api/hello\" hx-target=\"#out\" class=\"px-4 py-2 bg-slate-900 text-white rounded-md hover:bg-slate-700\">Say hello</button><div id=\"out\" class=\"mt-6 text-slate-700\"></div>")
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
return nil
|
||||
})
|
||||
templ_7745c5c3_Err = Layout("hostexecutor").Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func Hello(name string) templ.Component {
|
||||
return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
|
||||
templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
|
||||
if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
|
||||
return templ_7745c5c3_CtxErr
|
||||
}
|
||||
templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
|
||||
if !templ_7745c5c3_IsBuffer {
|
||||
defer func() {
|
||||
templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
|
||||
if templ_7745c5c3_Err == nil {
|
||||
templ_7745c5c3_Err = templ_7745c5c3_BufErr
|
||||
}
|
||||
}()
|
||||
}
|
||||
ctx = templ.InitializeContext(ctx)
|
||||
templ_7745c5c3_Var3 := templ.GetChildren(ctx)
|
||||
if templ_7745c5c3_Var3 == nil {
|
||||
templ_7745c5c3_Var3 = templ.NopComponent
|
||||
}
|
||||
ctx = templ.ClearChildren(ctx)
|
||||
templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 2, "<p>Hello, ")
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
var templ_7745c5c3_Var4 string
|
||||
templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(name)
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/web/index.templ`, Line: 15, Col: 17}
|
||||
}
|
||||
_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 3, "!</p>")
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
var _ = templruntime.GeneratedTemplate
|
||||
@@ -1,61 +0,0 @@
|
||||
// Code generated by templ - DO NOT EDIT.
|
||||
|
||||
// templ: version: v0.3.1020
|
||||
package web
|
||||
|
||||
//lint:file-ignore SA4006 This context is only used if a nested component is present.
|
||||
|
||||
import "github.com/a-h/templ"
|
||||
import templruntime "github.com/a-h/templ/runtime"
|
||||
|
||||
func Layout(title string) templ.Component {
|
||||
return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
|
||||
templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
|
||||
if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
|
||||
return templ_7745c5c3_CtxErr
|
||||
}
|
||||
templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
|
||||
if !templ_7745c5c3_IsBuffer {
|
||||
defer func() {
|
||||
templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
|
||||
if templ_7745c5c3_Err == nil {
|
||||
templ_7745c5c3_Err = templ_7745c5c3_BufErr
|
||||
}
|
||||
}()
|
||||
}
|
||||
ctx = templ.InitializeContext(ctx)
|
||||
templ_7745c5c3_Var1 := templ.GetChildren(ctx)
|
||||
if templ_7745c5c3_Var1 == nil {
|
||||
templ_7745c5c3_Var1 = templ.NopComponent
|
||||
}
|
||||
ctx = templ.ClearChildren(ctx)
|
||||
templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 1, "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><title>")
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
var templ_7745c5c3_Var2 string
|
||||
templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(title)
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ.Error{Err: templ_7745c5c3_Err, FileName: `internal/web/layout.templ`, Line: 9, Col: 17}
|
||||
}
|
||||
_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 2, "</title><script src=\"https://unpkg.com/htmx.org@2.0.0\"></script><script src=\"https://cdn.tailwindcss.com\"></script></head><body class=\"min-h-screen bg-slate-50 text-slate-900 antialiased\"><main class=\"max-w-3xl mx-auto px-6 py-12\">")
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
templ_7745c5c3_Err = templ_7745c5c3_Var1.Render(ctx, templ_7745c5c3_Buffer)
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 3, "</main></body></html>")
|
||||
if templ_7745c5c3_Err != nil {
|
||||
return templ_7745c5c3_Err
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
var _ = templruntime.GeneratedTemplate
|
||||
@@ -1,205 +0,0 @@
|
||||
"""loop.py — Karpathy-style autoresearch loop for jepa-fx-risk.
|
||||
|
||||
Agent (on iguana/berget — NOT koala, whose GPU is reserved for train.py) reads
|
||||
program.md + train.py + STATUS.md, proposes ONE change to train.py, we run it,
|
||||
keep if val_vol_r2 improved else git-revert. Appends per-iter record to STATUS.md.
|
||||
|
||||
LITELLM_KEY=xxx python loop.py [--iters N] [--model MODEL]
|
||||
|
||||
Env:
|
||||
LITELLM_KEY — LiteLLM master key (required)
|
||||
LITELLM_BASE — default http://localhost:30401/v1
|
||||
LOOP_MODEL — default berget/gemma4-31b (non-thinking; iguana/berget only)
|
||||
LOOP_ITERS — default 3
|
||||
TRAIN_TIMEOUT — seconds per train.py run, default 120
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import textwrap
|
||||
from pathlib import Path
|
||||
|
||||
import urllib.request
|
||||
|
||||
LITELLM_BASE = os.environ.get("LITELLM_BASE", "http://localhost:30401/v1")
|
||||
LITELLM_KEY = os.environ.get("LITELLM_KEY", "")
|
||||
LOOP_MODEL = os.environ.get("LOOP_MODEL", "berget/gemma4-31b")
|
||||
LOOP_ITERS = int(os.environ.get("LOOP_ITERS", "3"))
|
||||
TRAIN_TIMEOUT = int(os.environ.get("TRAIN_TIMEOUT", "120"))
|
||||
STATUS_MD = Path("STATUS.md")
|
||||
METRICS_JSON = Path("metrics.json")
|
||||
TRAIN_PY = Path("train.py")
|
||||
|
||||
AGENT_SYSTEM = textwrap.dedent("""\
|
||||
You are the autoresearch agent for jepa-fx-risk. Your job: propose ONE small,
|
||||
targeted change to train.py to improve val_vol_r2 (OOS R² predicting 1-day
|
||||
realized vol from frozen embeddings). Higher is better.
|
||||
|
||||
Rules:
|
||||
- Return ONLY the full new content of train.py — nothing else, no explanation,
|
||||
no markdown fence. Raw Python only.
|
||||
- Change ONE thing at a time (one knob, one structural idea).
|
||||
- Do NOT touch prepare_data.py, loop.py, or the data pipeline — only train.py.
|
||||
- Do NOT add new data sources or new files.
|
||||
- The metric is computed externally from your frozen embeddings; trust it.
|
||||
""")
|
||||
|
||||
|
||||
def read_file(p: Path) -> str:
|
||||
return p.read_text() if p.exists() else ""
|
||||
|
||||
|
||||
def gpu_snapshot() -> str:
|
||||
try:
|
||||
out = subprocess.check_output(
|
||||
["nvidia-smi", "--query-gpu=utilization.gpu,memory.used,memory.total,temperature.gpu",
|
||||
"--format=csv,noheader,nounits"], timeout=5, text=True
|
||||
).strip()
|
||||
util, mem_used, mem_total, temp = [x.strip() for x in out.split(",")]
|
||||
return "gpu=%s%% vram=%s/%sMiB temp=%s°C" % (util, mem_used, mem_total, temp)
|
||||
except Exception:
|
||||
return "gpu=N/A"
|
||||
|
||||
|
||||
def read_metric() -> float | None:
|
||||
if not METRICS_JSON.exists():
|
||||
return None
|
||||
try:
|
||||
return float(json.loads(METRICS_JSON.read_text())["val_vol_r2"])
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def run_train() -> tuple[float | None, float, str]:
|
||||
"""Run train.py. Returns (val_vol_r2 or None, wall_secs, stderr_tail)."""
|
||||
t0 = time.time()
|
||||
gpu_before = gpu_snapshot()
|
||||
try:
|
||||
r = subprocess.run(
|
||||
[sys.executable, "train.py"],
|
||||
capture_output=True, text=True, timeout=TRAIN_TIMEOUT,
|
||||
)
|
||||
elapsed = time.time() - t0
|
||||
if r.returncode != 0:
|
||||
return None, elapsed, (r.stderr or r.stdout)[-300:]
|
||||
metric = read_metric()
|
||||
return metric, elapsed, ""
|
||||
except subprocess.TimeoutExpired:
|
||||
return None, TRAIN_TIMEOUT, "TIMEOUT"
|
||||
|
||||
|
||||
def call_agent(iteration: int, best_so_far: float | None) -> str:
|
||||
"""Ask the LLM agent to edit train.py. Returns new train.py content."""
|
||||
context = "\n\n".join([
|
||||
"# program.md\n" + read_file(Path("program.md")),
|
||||
"# train.py (current)\n" + read_file(TRAIN_PY),
|
||||
"# STATUS.md (history)\n" + read_file(STATUS_MD)[-2000:],
|
||||
"# metrics.json (last run)\n" + read_file(METRICS_JSON),
|
||||
"Iteration %d. Best val_vol_r2 so far: %s. Improve it." % (
|
||||
iteration, "%.4f" % best_so_far if best_so_far is not None else "none yet"
|
||||
),
|
||||
])
|
||||
payload = json.dumps({
|
||||
"model": LOOP_MODEL,
|
||||
"messages": [
|
||||
{"role": "system", "content": AGENT_SYSTEM},
|
||||
{"role": "user", "content": context},
|
||||
],
|
||||
"temperature": 0.7,
|
||||
"max_tokens": 4096,
|
||||
}).encode()
|
||||
req = urllib.request.Request(
|
||||
LITELLM_BASE + "/chat/completions",
|
||||
data=payload,
|
||||
headers={"Authorization": "Bearer " + LITELLM_KEY,
|
||||
"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
resp = urllib.request.urlopen(req, timeout=60)
|
||||
data = json.load(resp)
|
||||
return data["choices"][0]["message"]["content"]
|
||||
|
||||
|
||||
def revert_train(original_content: str):
|
||||
TRAIN_PY.write_text(original_content)
|
||||
|
||||
|
||||
def append_status(line: str):
|
||||
with open(STATUS_MD, "a") as f:
|
||||
f.write(line + "\n")
|
||||
|
||||
|
||||
def main():
|
||||
if not LITELLM_KEY:
|
||||
print("ERROR: set LITELLM_KEY"); sys.exit(1)
|
||||
|
||||
if not STATUS_MD.exists():
|
||||
STATUS_MD.write_text("# Autoresearch STATUS\n\n| iter | val_vol_r2 | delta | action | secs | gpu | change |\n|------|-----------|-------|--------|------|-----|--------|\n")
|
||||
|
||||
# establish baseline
|
||||
baseline = read_metric()
|
||||
if baseline is None:
|
||||
print("No metrics.json — running train.py for baseline...")
|
||||
m, secs, err = run_train()
|
||||
if m is None:
|
||||
print("Baseline run failed:", err); sys.exit(1)
|
||||
baseline = m
|
||||
print("Baseline: val_vol_r2 = %.4f (%.1fs)" % (baseline, secs))
|
||||
|
||||
best = baseline
|
||||
print("Starting loop | model=%s | iters=%d | baseline=%.4f" % (LOOP_MODEL, LOOP_ITERS, best))
|
||||
|
||||
for i in range(1, LOOP_ITERS + 1):
|
||||
print("\n--- iter %d/%d ---" % (i, LOOP_ITERS))
|
||||
original = TRAIN_PY.read_text()
|
||||
|
||||
print(" calling agent (%s)..." % LOOP_MODEL)
|
||||
t_agent = time.time()
|
||||
try:
|
||||
new_code = call_agent(i, best)
|
||||
except Exception as e:
|
||||
print(" agent call failed:", e)
|
||||
append_status("| %d | ERR | — | agent-fail | — | — | %s |" % (i, str(e)[:60]))
|
||||
continue
|
||||
agent_secs = time.time() - t_agent
|
||||
print(" agent replied in %.1fs" % agent_secs)
|
||||
|
||||
# strip accidental markdown fences
|
||||
if new_code.strip().startswith("```"):
|
||||
lines = new_code.strip().splitlines()
|
||||
new_code = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:])
|
||||
|
||||
TRAIN_PY.write_text(new_code)
|
||||
|
||||
gpu = gpu_snapshot()
|
||||
print(" running train.py [%s]..." % gpu)
|
||||
metric, secs, err = run_train()
|
||||
|
||||
if metric is None:
|
||||
print(" train.py FAILED — reverting. err:", err[:100])
|
||||
revert_train(original)
|
||||
append_status("| %d | FAIL | — | revert | %.0fs | %s | run error |" % (i, secs, gpu))
|
||||
continue
|
||||
|
||||
delta = metric - best
|
||||
if metric > best:
|
||||
best = metric
|
||||
action = "KEEP"
|
||||
else:
|
||||
revert_train(original)
|
||||
action = "revert"
|
||||
|
||||
summary = "| %d | %.4f | %+.4f | %s | %.0fs | %s | iter%d |" % (
|
||||
i, metric, delta, action, secs, gpu, i)
|
||||
append_status(summary)
|
||||
print(" val_vol_r2=%.4f delta=%+.4f action=%s [%.0fs]" % (metric, delta, action, secs))
|
||||
|
||||
print("\nDone. Best val_vol_r2 = %.4f (baseline was %.4f, delta %+.4f)" % (best, baseline, best - baseline))
|
||||
print("STATUS.md updated.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,14 +0,0 @@
|
||||
{
|
||||
"val_vol_r2": 0.05988483092470609,
|
||||
"n_test": 263,
|
||||
"knobs": {
|
||||
"WINDOW": 60,
|
||||
"PATCH_LEN": 5,
|
||||
"STRIDE": 5,
|
||||
"D_MODEL": 64,
|
||||
"DEPTH": 2,
|
||||
"MASK_FRAC": 0.5,
|
||||
"SIGREG_LAM": 0.01,
|
||||
"EPOCHS": 300
|
||||
}
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
# Python deps for the autoresearch loop (train.py + scripts). Install torch from
|
||||
# the cu130 index FIRST (koala Blackwell sm_120, torch 2.12.1+cu130 verified):
|
||||
# pip install torch --index-url https://download.pytorch.org/whl/cu130
|
||||
# pip install -r requirements.txt
|
||||
numpy>=2.0
|
||||
pandas>=2.2
|
||||
pyarrow>=16
|
||||
histdata>=1.3 # histdata.com downloader (handles the tk token politely)
|
||||
@@ -1,13 +0,0 @@
|
||||
{
|
||||
"label": "null",
|
||||
"mean_sil": 0.018206419112781685,
|
||||
"pca_sil": 0.13589094579219818,
|
||||
"spread": 0.8673340065023978,
|
||||
"pc1_hv_corr": 0.525803392278542,
|
||||
"per_seed": [
|
||||
0.026790648698806763,
|
||||
0.010999602265655994,
|
||||
0.016829006373882294
|
||||
],
|
||||
"passed": false
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
# Phase-0 SSL feasibility gate — null
|
||||
|
||||
**Date:** 2026-06-24
|
||||
**Path B deviation:** Daily 2019-2023 (not hourly 2008-2022); Python harness
|
||||
(not Go #4); gate metric adapted from silhouette-on-embedding to match
|
||||
available data. Go harness (#4) remains open for production experiments.
|
||||
|
||||
## Data
|
||||
- Train: EUR/USD daily 2019-2021 (907 windows)
|
||||
- OOS: EUR/USD daily 2022-2023 (593 windows)
|
||||
- HV label: top-33% realized-vol days = high-volatility (196 days)
|
||||
|
||||
## Results
|
||||
| | Value | Gate |
|
||||
|---|---|---|
|
||||
| TS-JEPA mean silhouette (3 seeds) | 0.0182 | > 0.20 → **False** |
|
||||
| Beats PCA baseline (0.1359) | 0.0182 | > PCA → **False** |
|
||||
| Seed stability (spread) | 86.73% | < 10% → **False** |
|
||||
| PC1/HV correlation | 0.5258 | < 0.95 → **True** |
|
||||
|
||||
Per-seed: ['0.0268', '0.0110', '0.0168']
|
||||
|
||||
## Verdict: **NULL**
|
||||
|
||||
One or more gate criteria not met. See null result protocol in #5.
|
||||
@@ -1,21 +0,0 @@
|
||||
"""Phase-0 compute gate (brain wiki/jepa-fx/facts/autoresearch-integration-phase1):
|
||||
PyTorch cu130 must see the koala Blackwell GPU and compute before any experiment.
|
||||
|
||||
python scripts/check_gpu.py # exits 0 if the GPU is usable, 1 otherwise
|
||||
|
||||
Note: koala shares this 12GB card with the llama-swap LLM stack. The autoresearch
|
||||
agent should run on iguana/berget models so koala's GPU stays free for train.py.
|
||||
"""
|
||||
import sys
|
||||
import torch
|
||||
|
||||
print("torch", torch.__version__)
|
||||
if not torch.cuda.is_available():
|
||||
print("CUDA NOT AVAILABLE — gate BLOCKED")
|
||||
sys.exit(1)
|
||||
print("device:", torch.cuda.get_device_name(0))
|
||||
print("capability: sm_%d%d" % torch.cuda.get_device_capability(0))
|
||||
x = torch.randn(2000, 2000, device="cuda")
|
||||
(x @ x).sum().item()
|
||||
torch.cuda.synchronize()
|
||||
print("GPU matmul OK — Phase-0 compute gate GREEN")
|
||||
@@ -1,31 +0,0 @@
|
||||
"""Fetch EUR/USD M1 bars from histdata.com (free, research use).
|
||||
|
||||
Polite: one request per year, spaced; past years query month=None. Uses the
|
||||
maintained `histdata` package which handles histdata's anti-hotlink tk token.
|
||||
Output: data/raw/DAT_ASCII_EURUSD_M1_<year>.zip
|
||||
|
||||
YEARS=2019,2020,2021 python scripts/fetch_data.py
|
||||
"""
|
||||
import os
|
||||
import time
|
||||
|
||||
from histdata import download_hist_data
|
||||
from histdata.api import Platform as P, TimeFrame as T
|
||||
|
||||
YEARS = [y.strip() for y in os.environ.get("YEARS", "2019,2020,2021").split(",")]
|
||||
|
||||
|
||||
def main():
|
||||
os.makedirs("data/raw", exist_ok=True)
|
||||
for yr in YEARS:
|
||||
f = download_hist_data(
|
||||
year=yr, month=None, pair="eurusd",
|
||||
platform=P.GENERIC_ASCII, time_frame=T.ONE_MINUTE,
|
||||
output_directory="data/raw",
|
||||
)
|
||||
print("fetched", yr, "->", f)
|
||||
time.sleep(2) # be a good citizen
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,237 +0,0 @@
|
||||
"""Phase-0 SSL feasibility gate (path B — Python fast-close of #5).
|
||||
|
||||
Spec deviation documented: original spec (#5) required hourly 2008-2022 data
|
||||
and a Go eval harness (#4). Path B uses daily 2019-2023 + Python harness to
|
||||
close the gate quickly, since val_vol_r2 > 0 already demonstrates SSL
|
||||
feasibility. The Go harness (#4) remains open for production experiments.
|
||||
|
||||
Gate criteria (from #5):
|
||||
- Silhouette > 0.20 on held-out 2022-2023 (binary HV label: top-33% RV days)
|
||||
- TS-JEPA silhouette > PCA baseline silhouette
|
||||
- Rerun x3 seeds within ±10% of mean silhouette
|
||||
- PC1/HV correlation < 0.95 (sanity: not trivially memorising the label)
|
||||
|
||||
python scripts/phase0_gate.py
|
||||
"""
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
from sklearn.decomposition import PCA
|
||||
from sklearn.metrics import silhouette_score
|
||||
from sklearn.preprocessing import StandardScaler
|
||||
|
||||
SEEDS = [0, 1, 2]
|
||||
WINDOW = 30
|
||||
PATCH_LEN = 5
|
||||
STRIDE = 5
|
||||
D_MODEL = 32
|
||||
DEPTH = 2
|
||||
N_HEADS = 4
|
||||
EPOCHS = 400
|
||||
LR = 3e-4
|
||||
SIGREG_LAM = 0.5
|
||||
HV_PERCENTILE = 67 # top-33% = "high volatility"
|
||||
|
||||
dev = "cuda" if torch.cuda.is_available() else "cpu"
|
||||
|
||||
|
||||
# ── SIGReg ──────────────────────────────────────────────────────────────────
|
||||
|
||||
def sigreg(tokens: torch.Tensor, knots: int = 17) -> torch.Tensor:
|
||||
B, T, D = tokens.shape
|
||||
z = tokens.reshape(B * T, D).float()
|
||||
t = torch.linspace(0, 3, knots, device=z.device, dtype=z.dtype)
|
||||
dt = 3.0 / (knots - 1)
|
||||
w = torch.full((knots,), 2 * dt, device=z.device, dtype=z.dtype)
|
||||
w[0] = dt; w[-1] = dt
|
||||
phi = torch.exp(-t.square() / 2.0)
|
||||
A = torch.randn(D, 256, device=z.device, dtype=z.dtype)
|
||||
A = A / A.norm(p=2, dim=0)
|
||||
x_t = (z @ A).unsqueeze(-1) * t
|
||||
err = (x_t.cos().mean(0) - phi).square() + x_t.sin().mean(0).square()
|
||||
return ((err @ (w * phi)) * z.shape[0]).mean()
|
||||
|
||||
|
||||
# ── Encoder ──────────────────────────────────────────────────────────────────
|
||||
|
||||
class PatchEncoder(nn.Module):
|
||||
def __init__(self, in_feats, patch_len, stride, d_model, depth, n_heads):
|
||||
super().__init__()
|
||||
self.patch_len = patch_len
|
||||
self.stride = stride
|
||||
self.embed = nn.Linear(patch_len * in_feats, d_model)
|
||||
layer = nn.TransformerEncoderLayer(d_model, n_heads, 2 * d_model,
|
||||
dropout=0.0, batch_first=True)
|
||||
self.tf = nn.TransformerEncoder(layer, num_layers=depth)
|
||||
n_patches = (WINDOW - patch_len) // stride + 1
|
||||
pos = torch.zeros(n_patches, d_model)
|
||||
for p in range(n_patches):
|
||||
for i in range(0, d_model, 2):
|
||||
pos[p, i] = math.sin(p / 10000 ** (i / d_model))
|
||||
if i + 1 < d_model:
|
||||
pos[p, i+1] = math.cos(p / 10000 ** (i / d_model))
|
||||
self.register_buffer("pos", pos)
|
||||
|
||||
def forward(self, x):
|
||||
B, W, F = x.shape
|
||||
n_patches = (W - self.patch_len) // self.stride + 1
|
||||
patches = torch.stack([x[:, i*self.stride:i*self.stride+self.patch_len, :]
|
||||
.reshape(B, -1) for i in range(n_patches)], dim=1)
|
||||
tokens = self.embed(patches) + self.pos[:n_patches]
|
||||
return self.tf(tokens)
|
||||
|
||||
|
||||
# ── Data ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
def load_data():
|
||||
df = pd.read_parquet("data/processed/eurusd_daily.parquet").reset_index(drop=True)
|
||||
df["date"] = pd.to_datetime(df["date"])
|
||||
train = df[df["date"].dt.year <= 2021].copy()
|
||||
oos = df[df["date"].dt.year >= 2022].copy()
|
||||
|
||||
feats_all = df[["ret", "realized_vol"]].to_numpy(np.float32)
|
||||
target_all = df["realized_vol"].to_numpy(np.float32)
|
||||
dates_all = df["date"].values
|
||||
|
||||
mu = feats_all[:len(train)].mean(0)
|
||||
sd = feats_all[:len(train)].std(0) + 1e-8
|
||||
|
||||
def windows(df_subset, feats_norm, dates):
|
||||
idx_start = df.index[df["date"].isin(df_subset["date"])][0]
|
||||
X, oos_dates, oos_rv = [], [], []
|
||||
for t in range(idx_start + WINDOW, idx_start + len(df_subset)):
|
||||
X.append(feats_norm[t - WINDOW:t])
|
||||
oos_dates.append(dates[t])
|
||||
oos_rv.append(target_all[t])
|
||||
return np.stack(X), np.array(oos_rv), np.array(oos_dates)
|
||||
|
||||
feats_norm = (feats_all - mu) / sd
|
||||
|
||||
Xtr, rvtr, _ = windows(train, feats_norm, dates_all)
|
||||
Xte, rvte, te_dates = windows(oos, feats_norm, dates_all)
|
||||
|
||||
# binary HV label: top-33% realized vol days in OOS = "high volatility"
|
||||
hv_threshold = np.percentile(rvte, HV_PERCENTILE)
|
||||
hv_labels = (rvte >= hv_threshold).astype(int)
|
||||
|
||||
return Xtr, rvtr, Xte, rvte, hv_labels
|
||||
|
||||
|
||||
# ── Train + embed ─────────────────────────────────────────────────────────────
|
||||
|
||||
def train_and_embed(Xtr, Xte, seed):
|
||||
torch.manual_seed(seed)
|
||||
np.random.seed(seed)
|
||||
enc = PatchEncoder(Xtr.shape[2], PATCH_LEN, STRIDE, D_MODEL, DEPTH, N_HEADS).to(dev)
|
||||
pred = nn.Sequential(nn.Linear(D_MODEL, D_MODEL), nn.GELU(),
|
||||
nn.Linear(D_MODEL, D_MODEL)).to(dev)
|
||||
opt = torch.optim.AdamW(list(enc.parameters()) + list(pred.parameters()), lr=LR)
|
||||
|
||||
Xtr_t = torch.tensor(Xtr, device=dev)
|
||||
n_patches = (WINDOW - PATCH_LEN) // STRIDE + 1
|
||||
n_mask = max(1, int(0.30 * n_patches))
|
||||
|
||||
for ep in range(EPOCHS):
|
||||
idx_mask = torch.randperm(n_patches)[:n_mask]
|
||||
tokens_ctx = enc(Xtr_t)
|
||||
tokens_target = enc(Xtr_t).detach()
|
||||
jepa_loss = ((pred(tokens_ctx[:, idx_mask, :]) -
|
||||
tokens_target[:, idx_mask, :]) ** 2).mean()
|
||||
reg = sigreg(tokens_ctx)
|
||||
loss = jepa_loss + SIGREG_LAM * reg
|
||||
opt.zero_grad(); loss.backward(); opt.step()
|
||||
|
||||
enc.eval()
|
||||
with torch.no_grad():
|
||||
Ete = enc(torch.tensor(Xte, device=dev)).mean(1).cpu().numpy()
|
||||
|
||||
return Ete
|
||||
|
||||
|
||||
# ── Gate ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
def pca_baseline(Xte, hv_labels):
|
||||
flat = Xte.reshape(len(Xte), -1)
|
||||
sc = StandardScaler().fit(flat)
|
||||
emb = PCA(n_components=8).fit_transform(sc.transform(flat))
|
||||
return silhouette_score(emb, hv_labels), emb
|
||||
|
||||
|
||||
def main():
|
||||
os.makedirs("results/summaries", exist_ok=True)
|
||||
Xtr, rvtr, Xte, rvte, hv_labels = load_data()
|
||||
print(f"train={len(Xtr)} OOS={len(Xte)} HV={hv_labels.sum()}/{len(hv_labels)}")
|
||||
|
||||
pca_sil, pca_emb = pca_baseline(Xte, hv_labels)
|
||||
pc1 = pca_emb[:, 0]
|
||||
pc1_hv_corr = abs(np.corrcoef(pc1, hv_labels)[0, 1])
|
||||
print(f"PCA baseline silhouette = {pca_sil:.4f} | PC1/HV |r| = {pc1_hv_corr:.4f}")
|
||||
|
||||
sils = []
|
||||
for seed in SEEDS:
|
||||
emb = train_and_embed(Xtr, Xte, seed)
|
||||
sc = StandardScaler().fit(emb)
|
||||
sil = silhouette_score(sc.transform(emb), hv_labels)
|
||||
sils.append(sil)
|
||||
print(f" seed={seed} silhouette={sil:.4f}")
|
||||
|
||||
mean_sil = np.mean(sils)
|
||||
spread = (max(sils) - min(sils)) / mean_sil if mean_sil != 0 else 99
|
||||
|
||||
# gate checks
|
||||
g_sil = mean_sil > 0.20
|
||||
g_beats = mean_sil > pca_sil
|
||||
g_stable = spread < 0.10
|
||||
g_corr = pc1_hv_corr < 0.95
|
||||
passed = all([g_sil, g_beats, g_stable, g_corr])
|
||||
|
||||
label = "pass" if passed else "null"
|
||||
print(f"\nsilhouette mean={mean_sil:.4f} spread={spread:.2%} PCA={pca_sil:.4f} PC1/HV={pc1_hv_corr:.4f}")
|
||||
print(f"gate: sil>0.20={g_sil} beats_pca={g_beats} stable={g_stable} corr<0.95={g_corr}")
|
||||
print(f"PHASE-0: {label.upper()}")
|
||||
|
||||
summary = f"""# Phase-0 SSL feasibility gate — {label}
|
||||
|
||||
**Date:** 2026-06-24
|
||||
**Path B deviation:** Daily 2019-2023 (not hourly 2008-2022); Python harness
|
||||
(not Go #4); gate metric adapted from silhouette-on-embedding to match
|
||||
available data. Go harness (#4) remains open for production experiments.
|
||||
|
||||
## Data
|
||||
- Train: EUR/USD daily 2019-2021 ({len(Xtr)} windows)
|
||||
- OOS: EUR/USD daily 2022-2023 ({len(Xte)} windows)
|
||||
- HV label: top-{100-HV_PERCENTILE}% realized-vol days = high-volatility ({hv_labels.sum()} days)
|
||||
|
||||
## Results
|
||||
| | Value | Gate |
|
||||
|---|---|---|
|
||||
| TS-JEPA mean silhouette (3 seeds) | {mean_sil:.4f} | > 0.20 → **{g_sil}** |
|
||||
| Beats PCA baseline ({pca_sil:.4f}) | {mean_sil:.4f} | > PCA → **{g_beats}** |
|
||||
| Seed stability (spread) | {spread:.2%} | < 10% → **{g_stable}** |
|
||||
| PC1/HV correlation | {pc1_hv_corr:.4f} | < 0.95 → **{g_corr}** |
|
||||
|
||||
Per-seed: {[f"{s:.4f}" for s in sils]}
|
||||
|
||||
## Verdict: **{label.upper()}**
|
||||
|
||||
{"All 4 gate criteria met. TS-JEPA embeddings separate HV regimes significantly above PCA baseline with stable reproducibility." if passed else "One or more gate criteria not met. See null result protocol in #5."}
|
||||
"""
|
||||
path = f"results/summaries/phase-0-{label}.md"
|
||||
with open(path, "w") as f:
|
||||
f.write(summary)
|
||||
print(f"Written: {path}")
|
||||
|
||||
result = {"label": label, "mean_sil": mean_sil, "pca_sil": pca_sil,
|
||||
"spread": spread, "pc1_hv_corr": pc1_hv_corr,
|
||||
"per_seed": sils, "passed": passed}
|
||||
with open("results/summaries/phase-0-metrics.json", "w") as f:
|
||||
json.dump(result, f, indent=2)
|
||||
return 0 if passed else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,57 +0,0 @@
|
||||
"""LOCKED data pipeline (toy) — agent must NOT edit (brain Phase-1 contract).
|
||||
|
||||
Parses histdata EUR/USD M1 zips → daily series with realized volatility (the
|
||||
val_vol_r2 target = 1-day realized vol from intraday squared returns).
|
||||
Output: data/processed/eurusd_daily.parquet [date, close, ret, realized_vol].
|
||||
"""
|
||||
import glob
|
||||
import os
|
||||
import zipfile
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
|
||||
RAW = "data/raw"
|
||||
OUT = "data/processed/eurusd_daily.parquet"
|
||||
|
||||
|
||||
def load_m1() -> pd.DataFrame:
|
||||
frames = []
|
||||
for zp in sorted(glob.glob(os.path.join(RAW, "DAT_ASCII_EURUSD_M1_*.zip"))):
|
||||
with zipfile.ZipFile(zp) as z:
|
||||
csv = [n for n in z.namelist() if n.endswith(".csv")][0]
|
||||
with z.open(csv) as f:
|
||||
df = pd.read_csv(
|
||||
f, sep=";", header=None,
|
||||
names=["dt", "open", "high", "low", "close", "vol"],
|
||||
)
|
||||
df["ts"] = pd.to_datetime(df["dt"], format="%Y%m%d %H%M%S")
|
||||
frames.append(df[["ts", "close"]])
|
||||
out = pd.concat(frames).sort_values("ts").reset_index(drop=True)
|
||||
return out
|
||||
|
||||
|
||||
def main():
|
||||
m1 = load_m1()
|
||||
m1["r"] = np.log(m1["close"]).diff()
|
||||
m1["day"] = m1["ts"].dt.normalize()
|
||||
daily = m1.groupby("day").agg(
|
||||
close=("close", "last"),
|
||||
realized_vol=("r", lambda x: np.sqrt(np.nansum(x.values ** 2))),
|
||||
n_min=("r", "count"),
|
||||
).reset_index()
|
||||
daily = daily[daily["n_min"] > 60] # drop thin days (holidays)
|
||||
daily["ret"] = np.log(daily["close"]).diff()
|
||||
daily = daily.dropna().reset_index(drop=True)
|
||||
os.makedirs(os.path.dirname(OUT), exist_ok=True)
|
||||
daily[["day", "close", "ret", "realized_vol"]].rename(columns={"day": "date"}).to_parquet(OUT)
|
||||
print("rows:", len(daily), "| dates:", daily["day"].min().date(), "→", daily["day"].max().date())
|
||||
# sanity: the COVID crash (March 2020) must show a realized-vol spike
|
||||
rv = daily.set_index("day")["realized_vol"]
|
||||
mar20 = rv["2020-03-01":"2020-03-31"].max()
|
||||
typ = rv["2019-01-01":"2019-12-31"].median()
|
||||
print("median 2019 RV: %.5f | max Mar-2020 RV: %.5f | spike x%.1f" % (typ, mar20, mar20 / typ))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,174 +0,0 @@
|
||||
"""train.py — autoresearch agent file (only this may be edited).
|
||||
|
||||
TS-JEPA backbone with SIGReg regularization (Balestriero & LeCun, LeJEPA
|
||||
arXiv:2511.08544; time-series placement from ChronoJEPA arXiv: 2505.XXXXX).
|
||||
|
||||
PatchTST-style encoder over windowed daily [return, realized_vol] → FREEZE →
|
||||
linear probe predicts NEXT-day realized vol → val_vol_r2 (OOS R²).
|
||||
Writes metrics.json — the single scalar the loop reads.
|
||||
|
||||
Agent may tune: encoder depth/width, patch geometry, mask strategy, SIGReg
|
||||
lambda, optimizer. Do NOT touch prepare_data.py, loop.py, or the data pipeline.
|
||||
"""
|
||||
import json
|
||||
import math
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
# --- agent-tunable knobs ---
|
||||
WINDOW = 60 # INCREASED lookback for better volatility persistence capture
|
||||
PATCH_LEN = 5 # time-patch size (must divide WINDOW)
|
||||
STRIDE = 5
|
||||
D_MODEL = 64 # transformer hidden dim - INCREASED for capacity
|
||||
DEPTH = 2 # transformer layers
|
||||
N_HEADS = 4
|
||||
MASK_FRAC = 0.50 # INCREASED mask fraction to force the encoder to learn better global representations
|
||||
SIGREG_LAM = 0.01 # SIGReg weight (λ) - REDUCED to allow more representation capacity
|
||||
EPOCHS = 300
|
||||
LR = 3e-4
|
||||
SEED = 0
|
||||
# ---------------------------
|
||||
|
||||
torch.manual_seed(SEED)
|
||||
np.random.seed(SEED)
|
||||
dev = "cuda" if torch.cuda.is_available() else "cpu"
|
||||
|
||||
|
||||
# ── SIGReg (from LeJEPA/ChronoJEPA, token-level placement) ─────────────────
|
||||
|
||||
def sigreg(tokens: torch.Tensor, knots: int = 17) -> torch.Tensor:
|
||||
"""Epps-Pulley test statistic pushes token embeddings toward isotropic Gaussian.
|
||||
|
||||
tokens: (B, T, D) — applied per-token, averaged across B and T.
|
||||
"""
|
||||
B, T, D = tokens.shape
|
||||
z = tokens.reshape(B * T, D) # (N, D)
|
||||
t = torch.linspace(0, 3, knots, device=z.device, dtype=z.float().dtype)
|
||||
dt = 3.0 / (knots - 1)
|
||||
w = torch.full((knots,), 2 * dt, device=z.device, dtype=z.float().dtype)
|
||||
w[0] = dt; w[-1] = dt
|
||||
phi = torch.exp(-t.square() / 2.0)
|
||||
|
||||
A = torch.randn(D, 256, device=z.device, dtype=z.float().dtype)
|
||||
A = A / A.norm(p=2, dim=0)
|
||||
x_t = (z.float() @ A).unsqueeze(-1) * t # (N, 256, knots)
|
||||
err = (x_t.cos().mean(0) - phi).square() + x_t.sin().mean(0).square()
|
||||
return ((err @ (w * phi)) * z.shape[0]).mean()
|
||||
|
||||
|
||||
# ── Encoder + Predictor ─────────────────────────────────────────────────────
|
||||
|
||||
class PatchEncoder(nn.Module):
|
||||
"""PatchTST-style encoder for univariate windows."""
|
||||
def __init__(self, in_feats, patch_len, stride, d_model, depth, n_heads):
|
||||
super().__init__()
|
||||
self.patch_len = patch_len
|
||||
self.stride = stride
|
||||
self.d_model = d_model
|
||||
self.embed = nn.Linear(patch_len * in_feats, d_model)
|
||||
layer = nn.TransformerEncoderLayer(d_model, n_heads, 2 * d_model,
|
||||
dropout=0.0, batch_first=True)
|
||||
self.tf = nn.TransformerEncoder(layer, num_layers=depth)
|
||||
n_patches = (WINDOW - patch_len) // stride + 1
|
||||
pos = torch.zeros(n_patches, d_model)
|
||||
for p in range(n_patches):
|
||||
for i in range(0, d_model, 2):
|
||||
pos[p, i] = math.sin(p / 10000 ** (i / d_model))
|
||||
if i + 1 < d_model:
|
||||
pos[p, i+1] = math.cos(p / 10000 ** (i / d_model))
|
||||
self.register_buffer("pos", pos)
|
||||
|
||||
def forward(self, x: torch.Tensor) -> torch.Tensor:
|
||||
# x: (B, W, F) → patches → (B, T, D)
|
||||
B, W, F = x.shape
|
||||
n_patches = (W - self.patch_len) // self.stride + 1
|
||||
patches = torch.stack([x[:, i*self.stride:i*self.stride+self.patch_len, :]
|
||||
.reshape(B, -1) for i in range(n_patches)], dim=1)
|
||||
tokens = self.embed(patches) + self.pos[:n_patches]
|
||||
return self.tf(tokens) # (B, T, D)
|
||||
|
||||
|
||||
class Predictor(nn.Module):
|
||||
def __init__(self, d_model):
|
||||
super().__init__()
|
||||
self.net = nn.Sequential(nn.Linear(d_model, d_model), nn.GELU(),
|
||||
nn.Linear(d_model, d_model))
|
||||
def forward(self, x):
|
||||
return self.net(x)
|
||||
|
||||
|
||||
# ── Data ────────────────────────────────────────────────────────────────────
|
||||
|
||||
def build():
|
||||
df = pd.read_parquet("data/processed/eurusd_daily.parquet").reset_index(drop=True)
|
||||
feats = df[["ret", "realized_vol"]].to_numpy(np.float32)
|
||||
target = df["realized_vol"].to_numpy(np.float32)
|
||||
X, y = [], []
|
||||
for t in range(WINDOW, len(df) - 1):
|
||||
X.append(feats[t - WINDOW:t])
|
||||
y.append(target[t + 1])
|
||||
X = np.stack(X); y = np.array(y, np.float32)
|
||||
n_tr = int(0.7 * len(X))
|
||||
mu = X[:n_tr].mean((0, 1))
|
||||
sd = X[:n_tr].std((0, 1)) + 1e-8
|
||||
X = (X - mu) / sd
|
||||
return (X[:n_tr], y[:n_tr]), (X[n_tr:], y[n_tr:])
|
||||
|
||||
|
||||
# ── Training ─────────────────────────────────────────────────────────────────
|
||||
|
||||
def main():
|
||||
(Xtr, ytr), (Xte, yte) = build()
|
||||
n_feats = Xtr.shape[2]
|
||||
Xtr_t = torch.tensor(Xtr, device=dev)
|
||||
enc = PatchEncoder(n_feats, PATCH_LEN, STRIDE, D_MODEL, DEPTH, N_HEADS).to(dev)
|
||||
pred = Predictor(D_MODEL).to(dev)
|
||||
opt = torch.optim.AdamW(list(enc.parameters()) + list(pred.parameters()), lr=LR)
|
||||
|
||||
n_patches = (WINDOW - PATCH_LEN) // STRIDE + 1
|
||||
n_mask = max(1, int(MASK_FRAC * n_patches))
|
||||
|
||||
for ep in range(EPOCHS):
|
||||
# JEPA: predict masked-out patch tokens from visible tokens
|
||||
idx_mask = torch.randperm(n_patches)[:n_mask]
|
||||
ctx_mask = torch.ones(n_patches, dtype=torch.bool, device=dev)
|
||||
ctx_mask[idx_mask] = False
|
||||
|
||||
tokens_ctx = enc(Xtr_t) # encode all (B, T, D)
|
||||
tokens_target = enc(Xtr_t).detach() # target (frozen): same input, no grad
|
||||
pred_out = pred(tokens_ctx[:, idx_mask, :])
|
||||
jepa_loss = ((pred_out - tokens_target[:, idx_mask, :]) ** 2).mean()
|
||||
reg_loss = sigreg(tokens_ctx)
|
||||
loss = jepa_loss + SIGREG_LAM * reg_loss
|
||||
opt.zero_grad(); loss.backward(); opt.step()
|
||||
|
||||
enc.eval()
|
||||
with torch.no_grad():
|
||||
def embed(X_np):
|
||||
t = torch.tensor(X_np, device=dev)
|
||||
return enc(t).mean(1).cpu().numpy() # pool over time patches
|
||||
|
||||
Etr = embed(Xtr)
|
||||
Ete = embed(Xte)
|
||||
|
||||
# ridge linear probe (closed form)
|
||||
A = np.hstack([Etr, np.ones((len(Etr), 1))])
|
||||
w = np.linalg.solve(A.T @ A + 1e-3 * np.eye(A.shape[1]), A.T @ ytr)
|
||||
pred_np = np.hstack([Ete, np.ones((len(Ete), 1))]) @ w
|
||||
ss_res = ((yte - pred_np) ** 2).sum()
|
||||
ss_tot = ((yte - yte.mean()) ** 2).sum()
|
||||
val_vol_r2 = float(1 - ss_res / ss_tot)
|
||||
|
||||
json.dump({
|
||||
"val_vol_r2": val_vol_r2, "n_test": len(yte),
|
||||
"knobs": {"WINDOW": WINDOW, "PATCH_LEN": PATCH_LEN, "STRIDE": STRIDE,
|
||||
"D_MODEL": D_MODEL, "DEPTH": DEPTH, "MASK_FRAC": MASK_FRAC,
|
||||
"SIGREG_LAM": SIGREG_LAM, "EPOCHS": EPOCHS},
|
||||
}, open("metrics.json", "w"), indent=2)
|
||||
print("val_vol_r2 = %.4f (n_test=%d, dev=%s)" % (val_vol_r2, len(yte), dev))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user