PERF
Perfect Corp.
stock NYSE

$PERF buyout going through at $2/share ([link](https://ir.perfectcorp.com/financials/sec-filings/sec-filings-details/default.aspx?FilingId=19601251)). Didn't time it perfectly but set to book a 25% gain on this one

PERF finally announced take private deal. Was 1.65. Buyout $2

Perfect Corp. Enters into a Definitive Agreement for a Going-Private Transaction - PERF OTC Pink: PERFF

My two cents (LLM slop) :
I ain't no quant. Just some dude that gave up everything and locked in for 2 years, 11 months and 4 days.
Not sure I'll ever spill my beans this extensively ...
1. The Time‑Bar Problem: Compress First, Fail Later
A 1‑minute candle compresses a continuous, multi‑party negotiation into four numbers: open, high, low, close. Every boundary commitment that occurred inside that minute—every bid lifted, every offer hit, every short‑lived auction—is erased. The market does not respect your clock. A structural leg can start at 12:00:03 and end at 12:00:37, completely invisible to your bars. You cannot engineer a feature that recovers information that was never stored.
Your triple‑barrier labels compounded the error. “Take profit at 2× daily volatility, stop at 1×, 10‑day horizon”—those thresholds are your inventions. They have no structural meaning. The market never declared them. So your model learned to classify your own arbitrary boundaries, not the market’s actual commitments. In‑sample high accuracy, out‑of‑sample coin flip: textbook overfitting on noise.
2. From Prediction to Measurement: The Fractal Insight
The alternative is to stop trying to predict and start measuring. The market is a continuous, multi‑scale negotiation between participants with multiplicatively different time horizons. Every transaction is a commitment. The relevant question is not “will price hit my arbitrary profit target?” but “has the market committed to a directional move that exceeds a measurable structural boundary?” Those boundaries are fractal, and they are declared by the market itself.
Decades ago, Bill Williams recognized that markets are fractal—a 5‑minute chart and a daily chart exhibit the same structural patterns because they’re driven by the same underlying negotiation. His “fractal” indicator captured local reversals. It was a genuine breakthrough, but it was still trapped in bar charts. It still depended on the chosen time frame.
The next step is to liberate fractalisation from the time bar entirely. Instead of looking for patterns in candles, you instrument the tick stream with probes at multiple scales—spaced geometrically, not linearly—each one watching for a specific magnitude of price extension. When price moves far enough from a reference point and then retraces past a failure threshold, a probe fires an atomic signal. The pair of events (extension and retracement) is the market’s irreducible declaration of structure. It doesn’t matter whether it took three seconds or three days. The commitment was made.
3. The Grammar of Market Events
When you instrument the market this way, a remarkable thing happens: consecutive probe firings resolve into a grammar. They form shapes that are not patterns you invent—they are geometric consequences of the market’s own negotiation: Alpha (reversal downward after a rise), Echo (reversal upward after a fall), Charlie (continuation downward despite a bounce), Lima (continuation upward despite a dip), Foxtrot (indecision). These shapes are deterministic, computable without any lookahead, and they repeat across every scale.
When you see an Alpha‑Echo‑Alpha sequence across the meso‑macro probes, the market has authenticated a structural low. Echo‑Alpha‑Echo authenticates a high. These legs are the market’s own way of segmenting time—not by the clock, but by its commitments. A leg can last thirty seconds or thirty days. The instrument simply records when one begins and ends.
The output is a dense, immutable documentary tensor—I call it the LEAF—that, given the same tick stream, always produces the same result. Every event is auditable back to the exact tick that triggered it. That’s a property no candle‑based backtest can ever claim.
4. The RL Problem Reframed: Ride the Leg, Don’t Predict the Future
Once you have that structural record, the agent’s job changes completely. It no longer tries to guess which barrier will be hit. Instead, it answers a much more concrete question: “A structural leg has been authenticated. Should I enter? And if I do, how tightly should I trail my stop to capture the excursion without getting shaken out by sub‑auction noise?”
The agent sees a state assembled from seven streams: current LEAF slice, previous slice, event‑driven ROOT histories of the meso‑macro probes, a rolling narrative of the leg’s formation, a structural regime indicator, its own position (proprioception), and a behavioral mirror of recent rewards. The reward function is aligned with the instrument’s purpose: capture as much of the leg’s excursion as possible. Per‑step shaping encourages good behavior (cutting losers fast, holding through noise), but the terminal reward is always the capture ratio. The optimal policy is the same whether the leg lasts 30 seconds or 30 days.
5. The Neural Output: Semantic Action Representation
Every action the agent selects is wrapped in a single object—I call it a NeuralOutput. It’s not just an enum for “buy” or “sell.” It carries a semantic embedding that encodes the full intent of the decision: method (market entry, stop order, kill, trail, stay flat), direction, exposure delta, and anchor type (current price, sub‑auction extreme, chop‑envelope high/low). This embedding is a compact float vector.
The agent’s policy network doesn’t output a raw action ID—it outputs the embedding, which is then projected into a concrete command by a validation engine that is identical in training and live trading. That engine checks the action against the vehicle’s current exposure (am I already long? do I have a pending stop?) and either approves, warns, or rejects it. Invalid actions are penalized immediately and never reach the simulator.
This design means the agent can generalize across actions that share semantics. A “place stop” with anchor type “sub‑auction end” and a “market entry” with anchor type “current price” are represented as nearby vectors. The network learns the geometry of action space, not just a one‑hot lookup table.
6. The DQN Architecture: Multi‑Stream Attention
The agent’s brain is a Deep Q‑Network with a multi‑head attention architecture specifically designed for the seven observation streams. Each stream—current LEAF slice, previous slice, ROOT histories, FOLD narrative, CHOP regime, PING proprioception, PERF mirror—is compressed by its own attention head into a small summary vector. The summaries are concatenated and passed through a two‑layer MLP (128 → 64 → 14 Q‑values). No single feature is hand‑crafted; the attention heads learn to focus on the relevant parts of each stream.
Training uses standard DQN with experience replay, a target network updated periodically, and epsilon‑greedy exploration. The replay buffer stores transitions of (state, action embedding, reward, next state, done). Because the environment is deterministic and the state is immutable, transitions are perfectly reproducible.
Critically, the gradient computation runs on a separate thread, fed by a signal channel. The RL loop that consumes LEAF slices simply posts an integer when a batch is ready and continues processing. The training thread samples the batch, runs forward/backward passes, and updates weights independently. This decoupling lets the pipeline sustain thousands of slices per second even while training full‑time.
7. The Engineering Discipline That Keeps It Alive
None of this works without a codebase that respects the same boundaries as the philosophy. For a solo developer, architectural discipline is not optional—it’s survival.
Separation of concerns. Every component does exactly one thing. Probes measure; they never know about orders or rewards. The LEAF records; it never decides. The grammar classifies; it never trades. The environment evaluates; it never learns. The agent learns; it never executes. The vehicle executes; it never reasons. When something breaks, the failure is isolated. I can unit‑test the probes with a canned tick stream, verify the LEAF, then test the grammar, then the agent. No cascade of side effects.
Deterministic state. The agent’s entire observation is built from the LEAF and cached position pointers. The LEAF is deterministic—same ticks, same record. That makes the RL environment stationary. The replay buffer stores perfectly reproducible transitions.
Live/training symmetry. The validation engine is shared 100% between modes. In training, the validated command goes to a simulated order book inside the tick‑advance loop. In live, it goes out over the broker. No special “training mode” shortcuts. If something fails live, I can replay the exact ticks and reproduce it.
Training speed. The measurement and training loops run on separate cores, communicating through channels. A full month of ETHUSD tick data (\~2.9 million ticks, \~900,000 structural events) is ingested, measured, and explored by the agent in about six minutes. A year in roughly 72 minutes. This speed turns RL from a batch‑overnight ordeal into an interactive research loop—you can tune hyperparameters, iterate curricula, and deploy within an afternoon.
8. You Didn’t Fail—the Paradigm Did
The edge is in refusing to compress the market into time slices in the first place. Tick data alone isn’t enough—you need a measurement philosophy that treats the market as a continuous, multi‑scale commitment machine. Once you stop compressing and start measuring, the information is there. It has a grammar. It is learnable.
Bill Williams glimpsed the fractal truth decades ago, but he was still trapped in bars. Liberate fractalisation from time entirely, instrument the tick stream, and let the market segment itself. Build an instrument, not a predictor. Then let a simple RL agent with semantic action representations and multi‑stream attention learn to ride what the market has already declared. Back it all with the engineering discipline to keep the system alive for years as a solo developer.
Your instincts are good—you just need a different primitive.