Upload 22 files

BLOG_DRAFT.md

@@ -1,69 +1,100 @@
-# Field Notes: Putting a 20-Year-Old Chinese Trading Theory on a 4B Model
+# Field Notes: Putting a 20-Year-Old Chinese Trading Theory on a Fine-Tuned 1.7B
 
-*Built for the Build Small hackathon — a Gradio Space, a llama.cpp runtime, and zero cloud APIs.*
+*Built for the Build Small hackathon — a Gradio Space, a local llama.cpp sub-agent pool, a model I fine-tuned myself, and zero cloud APIs.*
 
 ## The problem (a real one)
 
 My family trades US stocks using 缠论 (Chan theory) — a Chinese technical-analysis
 framework built on fractals, strokes, segments and "pivots" (中枢), famous for its
 rigor and infamous for its complexity. We had a battle-tested Python engine that
-decomposes monthly → weekly → daily → 60m → 30m charts and emits the classic
-three buy / three sell points. Two problems: the engine's reasoning logs are
-dense Chinese jargon, and someone had to run it by hand every evening.
+decomposes monthly → weekly → daily → 60m → 30m → 15m → 5m charts and emits the
+classic three buy / three sell points. Two problems: the engine's reasoning logs
+are dense Chinese jargon, and someone had to run it by hand every evening.
 
 **Chan Compass** fixes both: a Gradio Space that auto-updates after the US close
 (18:10 ET), answers exactly one question per ticker — *do I buy or sell tomorrow,
-in which price zone, and where am I wrong?* — and uses a small local model as the
-translator and analyst the rule engine can't be.
+at what buy point, in which zone, and where am I wrong?* — and uses a pool of small
+local models as the translators and analysts the rule engine can't be.
 
-## Why a small model is the honest fit
+## Why small models are the honest fit
 
-This is the part I want to stress: the LLM is **not** doing the math. Fractal
-merging, divergence grading and nested-interval confirmation are deterministic
-code — a 32B (or 320B) model would add nothing but hallucination risk. What the
-rule engine can't do is *language*: explain a Chinese decision chain in plain
-English, brief today's headlines on my holdings, narrate sector rotation, write
-a structured research note. That's bounded, evidence-grounded text work — exactly
-what Qwen3-4B (Q4_K_M, ~2.5 GB) handles on 8 CPU cores. The constraint wasn't a
-limitation; it drew the architecture: **rules compute, the small model speaks.**
+The LLMs are **not** doing the math. Fractal merging, divergence grading and
+nested-interval confirmation are deterministic code — a 32B (or 320B) model would
+add nothing but hallucination risk and latency. What the rule engine can't do is
+*language*: turn a Chinese decision chain into a plain-English summary, brief
+today's headlines on my holdings, narrate sector rotation, write a structured
+research note. That's bounded, evidence-grounded text work — exactly what 1.7B–4B
+models handle on 8 CPU cores. The constraint drew the architecture: **rules
+compute, small models speak.**
+
+## A pool of sub-agents, not one model
+
+Early versions shared a single model behind one lock, so the moment two features
+ran at once you'd get "model busy." The fix was a **sub-agent pool** — four small
+models, each with its own lock, running through llama.cpp:
+
+* **Summary** (Signals → AI Summary) — my **fine-tuned Chan-Tuned Qwen3-1.7B**
+* **Narrator** (sector rotation) — Qwen3-1.7B
+* **Reporter** (watchlist news + research support) — Qwen3-1.7B
+* **Analyst** (Auto Research) — Qwen3-4B
+
+They genuinely run in parallel: you can stream a research report while the Signals
+summary writes, with no collision.
+
+## The fine-tune (the part I'm proudest of)
+
+The Summary sub-agent runs a model I trained myself. The app captures every
+(raw read → English summary) pair it produces into a dataset on the `/data`
+bucket; a couple hundred focused pairs later, I exported the JSONL straight from
+the app's Model tab, LoRA-tuned **Qwen3-1.7B** on a free Colab T4 with Unsloth,
+converted to GGUF, and published it to the Hub
+(`ranranrunforit/chan-compass-qwen3-1.7b-gguf`). One line in `MODEL_ZOO` wires it
+back in. The loop closes: the app generated its own training data, and now runs on
+the model that data produced — a 1.7B doing one job well instead of a giant model
+doing everything adequately.
 
 ## What's in the box
 
-* **Tomorrow's plan** — one row per ticker: BUY/SELL/HOLD/WAIT, entry zone,
-  invalidation price. Long-hold mode: ride the weekly pivot uplift, exit only on
-  third-sell / structural stop / an armed nested-interval line.
-* **Sector rotation** — flow proxy (Δ% × dollar volume) across the 11 SPDR
-  sector ETFs vs SPY, 1/5/20-day windows, with an on-demand AI narrative.
-* **Auto Research agent** — PLAN → five evidence tools (fundamentals, quarterly
-  financials, price action, *the Chan engine itself*, news) → sectioned report
-  (valuation · moat & supply-chain position · bull/bear · Chan timing · risks).
-  Every step is logged to a JSON trace; new tickers entering the pool get a
-  report generated automatically by the daily pipeline.
-* **Spectrum 2 UI** — Adobe's design language approximated in Gradio CSS:
-  pill buttons, `#0265DC`, Source Sans 3.
-
-## Three things I learned the hard way
-
-1. **HF Spaces build containers are tiny.** `llama-cpp-python` compiling from
-   source got OOM-killed at build time — on a Space with 32 GB of *runtime* RAM.
-   Fix: install the runtime at first launch instead (prebuilt CPU wheel, with a
-   memory-capped compile fallback), persisted to the `/data` storage bucket so
-   it happens exactly once. Also: pin `python_version: 3.11`, because prebuilt
-   wheels stop at 3.12.
-2. **Don't put the model on the hot path.** My first version generated an AI
-   rotation narrative inside "Run analysis" — 10 tickers took 186 s. Moving all
-   LLM calls to on-demand buttons and parallelizing the data downloads brought
-   the rule-engine path to a few seconds. CPU inference is fine for a 4B model;
+* **Tomorrow's plan** — one row per ticker: BUY/SELL/HOLD/WAIT, explicit **buy
+  point**, entry zone, invalidation price. Long-hold mode: ride the weekly pivot
+  uplift, exit only on third-sell / structural stop / an armed nested-interval line.
+* **Sector rotation** — flow proxy (Δ% × dollar volume) across the 11 SPDR sector
+  ETFs vs SPY, 1/5/20-day windows, instant tables + on-demand AI narrative.
+* **Watchlist news** — today-only headlines per holding, streamed as they arrive,
+  each with an AI brief.
+* **Multi-agent Auto Research** — PLAN → six evidence tools in parallel
+  (fundamentals, financials, price, *the Chan engine itself*, money-flow proxy,
+  news) → Analyst and Reporter writing different sections **simultaneously**:
+  valuation · tech moat · supply-chain map with tickers · bull/bear · money flow ·
+  Chan timing · risks. Every run writes a full JSON trace — the plan, each tool
+  call and its result, each sub-agent's request and response — **published as a Hub
+  dataset** so anyone can see how the agent actually reasoned.
+* **Email any result** — each tab can email its output; on HF (where SMTP is
+  blocked) delivery goes over the Resend HTTPS API, markdown rendered to clean HTML.
+* **Spectrum 2 UI** — Adobe's design language in Gradio.
+
+## Four things I learned the hard way
+
+1. **HF build containers are tiny.** `llama-cpp-python` got OOM-killed compiling at
+   *build* time on a Space with 32 GB of *runtime* RAM. Fix: install the runtime at
+   first launch (prebuilt CPU wheel, capped-compile fallback), persisted to `/data`
+   so it happens once. Pin `python_version: 3.11` — prebuilt wheels stop at 3.12.
+2. **Don't put the model on the hot path.** My first "Run analysis" generated an AI
+   narrative inline — 10 tickers took 186 s. Moving all LLM calls off the rule path
+   and parallelizing downloads brought it to a few seconds. CPU inference is fine;
    it just can't be a synchronous dependency of everything.
-3. **Global CSS is a loaded gun.** A single `button { border-radius: 999px }`
-   for Spectrum-style pills turned Gradio Dataframe's internal sort/fullscreen
-   icons into giant ovals floating over the data. Scope your selectors.
+3. **One lock per model.** A shared lock turns concurrent features into "model
+   busy." A sub-agent pool — one instance and lock per job — fixed it and made the
+   fine-tune swappable for just the one agent that needed it.
+4. **Platforms block SMTP; ship HTTPS email.** Outbound mail ports are closed on
+   Spaces, so email failed with "network unreachable." The Resend REST API over
+   443 works — and it needs a `User-Agent` header or Cloudflare 403s you.
 
 ## What's next
 
-A LoRA fine-tune of Qwen3-1.7B on pairs of (Chan decision chain → plain-English
-explanation) mined from the app's own logs — making the tiniest model the best
-Chan translator on the Hub — and publishing the agent traces as a dataset.
+The agent traces are already public as a Hub dataset; next I want to grow the
+fine-tune set so the Summary model keeps sharpening on exactly the phrasing this
+task needs, and feed real family usage back into that loop.
 
 *Not investment advice. Engine logic unchanged from the original; the app around
-it is what this hackathon built.*
+it — and the model that explains it — is what this hackathon built.*

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+WORKDIR /app
+
+# system deps for building wheels if needed
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential git curl && rm -rf /var/lib/apt/lists/*
+
+COPY --chown=user requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    AUTO_LOAD_MODEL=1
+
+EXPOSE 7860
+CMD ["python", "app.py"]