Featured image of post LynxCrypto Tools Edition: From Setting Up the Environment to Professional-Grade Quant Researcher — My Roadmap and Every Tutorial
量化交易

LynxCrypto Tools Edition: From Setting Up the Environment to Professional-Grade Quant Researcher — My Roadmap and Every Tutorial

Why top quants don't use TradingView for research; the five-level roadmap of Jupyter+vectorbt+Freqtrade; resources for real alpha (all verified) and the honest ceiling — 97% of retail day traders lose money, Quantopian shut down, and no course can teach you to be profitable.

Three most valuable conclusions up front:

  1. Nobody at a top quant firm uses TradingView for strategy research. Jane Street writes OCaml firm-wide; Two Sigma/Citadel use Python+Java+Spark; HFT is Python research + C++ execution. TradingView is only the “eyes” (charts + watchlist + alerts), not the “brain.”
  2. The right division of labor for a solo researcher: Jupyter+vectorbt as the brain (strategy discovery), a self-written engine or Freqtrade as the hands (trustworthy backtest + live trading), Plotly/QuantStats as the mirror (equity curves and drawdowns), TradingView as the eyes only.
  3. You can install the tools in a month; the methodology takes a year. What separates professionals from amateurs isn’t how many libraries you know — it’s whether you understand the four backtest biases, multiple-testing correction, and “why a strategy that printed money in backtest bleeds money live.”

0. Aligning the Ledger First: Why I Need a “Research Environment”

Conclusions from the previous two posts: with my $880 principal, my original goal of “turn 800 into 1000 daily, skim 200” was falsified by my own feasibility gate (feasibility_gate.py) — that would require 25% daily returns and an annualized Sharpe above 31, while the best fund in history, Renaissance, annualizes 66% with a Sharpe around 2. Based on the true expectancy of the best strategy in my gallery (MacdCross-4h), a realistic goal is about $1.5 per day, 67% annualized.

That means my job is not “find a faster money printer” but research strategies systematically, over the long term. And research needs an environment: one that can load data, test ideas, show me a curve instantly, and record every experiment.

That environment is what this post builds. It has five layers, and I’ll explain them by “when you use each one.”

1. The Five-Layer Map: A Day in the Life of a Professional Quant Researcher

A professional quant researcher’s workflow breaks down into five stages, each with its own class of tools:

1
2
3
4

Data → Research → Validation → Execution → Review
 ↓      ↓      ↓      ↓      ↓
ccxt  Jupyter  self-written  Freqtrade  Plotly
pandas vectorbt engine WFO+stats /own bot  QuantStats
  • Data layer: pull candles and funding rates from exchanges. Tools: ccxt + pandas.
  • Research layer: test ideas, sweep parameters, look at curves. Tools: JupyterLab + vectorbt + Plotly. This is the brain — 80% of your time goes here.
  • Validation layer: prove the strategy isn’t overfit. Tools: self-written event-driven engine (my LynxCrypto) + WFO + Deflated Sharpe. This is the line between amateur and professional.
  • Execution layer: run the strategy live. Tools: Freqtrade or a self-written bot + exchange APIs.
  • Review layer: read performance reports, attribution. Tools: QuantStats + your own journal.

One counterintuitive point: of these five layers, execution is the least important. Retail traders spend 90% of their time agonizing over which framework to place orders with; professional firms spend 90% of their time on research and validation. Anyone can place an order — “knowing whether this order should be placed at all” is the scarce skill.

2. Level 1 (Weeks 1–2): The Python Data Stack — “Literacy” for Research

The goal of this stage: given any chunk of candlestick data, compute any indicator in three lines of code, and know exactly what each line is doing.

NumPy — Vectorized Thinking

Everything in quant is array operations. You have to break the instinct to “for-loop over every candle” and replace it with “operate on the entire array at once.”

  • NumPy official Quickstart (free, beginner) — if you have Python basics, go straight here; the core idea is “replace loops with vectorization.”
  • Python for Data Analysis, Chapter 4: NumPy Basics (free online edition, beginner→intermediate) — the clearest chapter anywhere on boolean indexing, broadcasting, and array-oriented programming. The book is by pandas author Wes McKinney, the whole thing is free online, and it’s my main textbook for this stage.

pandas — The Native Language of Quant Research

pandas’ time-series functionality is the entire daily life of quant research: resample (15m into 4h), rolling (rolling windows), ewm (exponential weighting, used for MACD/EMA), shift (the key to avoiding look-ahead).

Pass bar: without looking at docs, write the chain “resample 15m candles into 4h, compute EMA12/26, use shift so the signal only uses the previous bar’s data.” Every piece of indicator code in my LynxCrypto engine is exactly this difficulty.

3. Level 2 (Weeks 2–4): JupyterLab — The Main Battlefield of Research

Jupyter is the standard kit for professional quant research — Two Sigma even open-sourced a whole suite of Jupyter extensions. Its value isn’t “it can run code”; it’s that it turns research into an explorable, recordable, reproducible process: each cell tests one idea, a chart appears immediately, bad ideas get thrown away on the spot, good ideas stay in the notebook as a research log.

The three most important work habits (things tutorials don’t teach but professional shops all do):

  1. One notebook = one research question. Don’t test ten ideas in one notebook — three months later even you won’t understand it.
  2. Write the hypothesis and conclusion at the top of the notebook. When you revisit it months later, read what you were trying to verify and what you concluded first, then the code.
  3. Don’t let notebooks become a stew. Explore in notebooks; extract settled logic back into .py modules (my strategies all live in lynxcrypto/strategy/), and keep notebooks for the “research process” only. This is the most common anti-pattern.

Pass bar: after installing, run my first experiment — cd /home/li/lynxcrypto && .venv/bin/jupyter lab, break the logic of render_report.py into a few cells, change one parameter, and see the equity curve change immediately.

4. Level 3 (Months 1–2): vectorbt + Plotly — The Strategy Discovery Factory

This is the core of the brain. vectorbt vectorizes backtesting — it runs thousands of parameter combinations in one go — which is the essential difference from an event-driven engine (which walks candle by candle): one is for “discovery,” the other for “validation.”

  • vectorbt official Getting Started (free, beginner→intermediate) — uses a dual moving-average crossover to demonstrate the core paradigms of vectorized backtesting and parameter sweeps.
  • vectorbt official Features page (free, intermediate) — pandas acceleration, CCXT data fetching, indicator factories, signal generation, portfolio modeling, QuantStats integration — it’s all here.
  • vectorbt official example notebooks (free, intermediate) — a goldmine. Runnable Jupyter examples: WalkForwardOptimization, PortfolioOptimization, StopSignals, and more. Copy them and you’re up and running.

The companion charting tool, Plotly:

One pitfall: plotly 7 conflicts with vectorbt 1.x (throws Invalid property scattermapbox); pin plotly<6. I’ve already installed and verified this in my .venv.

Pass bar: use vectorbt to sweep the parameters (fast/slow/signal) of a “MACD golden/death cross” strategy, plot a parameter-vs-return heatmap, and see with your own eyes “which parameters sit on a real plateau and which are isolated spikes.” Isolated spike = overfit; plateau = possibly real. This one chart pays back the entire learning cost.

5. Level 4 (Months 3–6): The Validation Layer — Where Amateur and Professional Diverge

By this level, you’ll have written many strategies that “printed money in backtest.” The entire point of this layer is: kill them with your own hands, and keep only the ones that refuse to die.

The Four Ways Backtests Die

  • QuantStart, Successful Backtesting Part I (free, required intermediate reading) — a systematic treatment of the four major biases: optimization bias (overfitting), look-ahead bias (peeking at the future), survivorship bias, and psychological-tolerance bias. My “15m naked mean reversion” strategy, which I falsified in the previous post, died of the first two.

Out-of-Sample Validation

  • vectorbt official WalkForwardOptimization notebook (free, intermediate) — a runnable example of rolling-window out-of-sample validation. My run_wfo.py follows exactly this idea: cut history into segments; on each segment, pick parameters using only earlier data and validate on later data.

Statistical Significance (The Most Advanced Part)

  • Bailey & López de Prado, The Deflated Sharpe Ratio (free, download after SSRN registration, professional-grade) — when you’ve tried 100 strategies, the best one showing Sharpe 2.5 is very likely luck. DSR corrects the false significance that comes from “trying too many times.” It’s the final gate in my triple validation (WFO + MCPT + DSR/PBO).
  • Hudson & Thames, Does Meta Labeling Add to Signal Efficacy? (free, professional-grade) — a reproduction of the core methods from López de Prado’s Advances in Financial ML: triple-barrier labeling, meta-labeling, feature lags against look-ahead, strict train/valid/OOS separation. If you want to touch the threshold of institutional-grade research, read this.

Pass bar: given any “backtest money printer,” state which biases it probably died of and write the corresponding test code. That’s how my MacdCross-4h was filtered out: 14 strategies × 4 timeframes, only it passed the full-sample first screen; after stripping beta, alpha was 132% annualized with t=2.35 — but it hasn’t passed the WFO final review yet, so it still can’t go live.

6. Level 5 (Months 6–12): The Execution Layer + The Reality of Real Alpha

By this level, you should have 1–2 strategies that survived all validation. Only now do we talk about live trading.

Execution Tools

  • Freqtrade official docs (free, beginner) — supports OKX spot and futures, with the full backtest/hyperopt/dry-run/Telegram-control pipeline. If you don’t want to write your own execution layer, use this. The key is its dry-run mode: run fake money for a few weeks first, then talk about real money.
  • Freqtrade Lookahead-analysis docs (free, intermediate) — a command dedicated to detecting look-ahead bias in strategies; mandatory before going live.
  • Freqtrade Hyperopt docs (free, intermediate) — Optuna-based hyperparameter optimization, with anti-overfitting caveats.
  • CCXT Manual (free, beginner) — if you write your own execution layer, this is the authoritative reference for the unified API; read it together with the OKX official API docs.
  • Advanced: nautilus_trader official docs (free, professional-grade) — an event-driven framework with a Rust core and Python interface, tick/order-book precision, the closest thing to professional-firm standards. Steep learning curve — touch it only when you truly need it.

One Certain Free Lunch: Funding-Rate Arbitrage

The only “structurally positive-expectancy” strategy in crypto is funding-rate arbitrage (long spot + short perp, collect funding); ZEC’s funding rate stays positive over the long term, roughly 5–10% annualized. It won’t make me rich, but $880 picking up a free $70–90 a year is one of the few “guaranteed wins” in this game. A verifiable path to implementation: Freqtrade’s futures/leverage docs.

But 8% Isn’t Enough — Where’s the Real Alpha?

That’s the question I chased after writing the paragraph above: funding-rate arbitrage is just a free lunch — can real alpha (excess returns) actually be learned? I ran another dedicated round of research and verified dozens of courses, books, and communities. The answer is harsher than “8%” — and more honest.

The single most important sentence first: no course can “teach you to be profitable.” Every legitimate resource only teaches “how to research rigorously”; none teaches “how to profit with certainty” — because the latter doesn’t exist in public markets. Anything claiming “finish this course and you’ll be consistently profitable” is a grift (the paid-alpha-community/signal-group business model is membership fees + exchange referral rebates; treat anyone who posts screenshots but won’t give auditable read-only live records as a scammer). Being able to tell “teaches methods” apart from “promises profits” already filters out 90% of the suckers.

Resources That Genuinely Teach “Researching Alpha” (All Verified)

  • Georgia Tech CS 7646 — Machine Learning for Trading (free, beginner→intermediate) — all public-version materials are free. Market mechanics, portfolio optimization, ML/reinforcement learning for trading decisions. The model of “teaches methods,” promises no profits, best for building foundations.
  • Stefan Jansen, Machine Learning for Algorithmic Trading (code MIT open-source and free, book paid, intermediate→advanced) — of the four classics, this one fits the “crypto + Python + solo” profile best. Among its 9 asset-class case studies there’s explicitly “Crypto Perps — Funding-rate arbitrage”; its methodology is the hardest-core: walk-forward, Deflated Sharpe, White’s Reality Check, and “exploration vs. confirmation” as a core discipline.
  • Ernest Chan, Algorithmic Trading / Machine Trading (beginner→intermediate) — the most honest “retail reality” books: Chan is himself an independent trader and directly discusses what small capital can and cannot do. More down-to-earth than López de Prado.
  • López de Prado, Advances in Financial ML (advanced) — the anti-overfitting bible (triple-barrier, purged k-fold, fractional differentiation), but abstract and math-heavy — not suitable as the first book for a beginner with $880.
  • WorldQuant University MSc in Financial Engineering (fully free, 2 years, DEAC-accredited) — if you want a proper credential and systematic training, apply for this; slow but zero cost.

Honest Counter-Evidence (This Section Is Worth More Than Any Tutorial)

I have to spell out the bad news in full, otherwise this post is selling a dream:

  • Brazilian whole-market study (Chague et al. 2020, Day Trading for a Living?): of individual day traders who persisted for more than 300 days, 97% lost money, only 0.4% earned more than a bank teller (about $54/day), and there is no learning effect — you don’t get better with practice.
  • Taiwanese whole-market study (Barber et al. 2009): individual investors underperform by 3.8 percentage points per year, with aggregate losses equivalent to 2.2% of Taiwan’s GDP.
  • Quantopian’s shutdown (2020): it crowdsourced alpha from 210,000+ quant enthusiasts, raised $48.8M from a16z and Point72, and ultimately liquidated and returned money because “the crowdsourced strategies underperformed in practice.” This was a public failure of “retail alpha is hard to find” at institutional scale.
  • My research found not a single public, independently verifiable record of a retail trader with sustained (>2 years) profitability on crypto perpetuals. Public “profit screenshots” come almost entirely from course sellers, referral hustlers, or bull-market beta (the coin went up, so they made money — that’s not alpha).
  • Your counterparty is Jane Street, Jump, Wintermute — with colocated servers, market-making rebates, and latency advantages. You will not beat institutions at HFT or market making.

The Honest Ceiling for $880

  • Capital ceiling: even at an excellent retail level of 20–30%/year, the absolute return is $176–264/year — you’d make more spending those same hundreds of hours doing Python freelance work. For you, quant is a skill investment + hobby, not a get-rich-quick path.
  • Strategy ceiling: what you can reliably capture is mid/low-frequency opportunities that institutions find too small or too bothersome — funding rates, cross-exchange spreads, certain new-listing effects, some on-chain-data alpha. Not HFT or market making.
  • Probability ceiling: the academic data says that even full-time and methodical, the probability of an individual consistently beating the market through trading is in the single-digit percentages. “Research real alpha and profit from it” is possible, but it’s closer to startup success rates than to “finish the course and get the job.”

So My Own Realistic Path

  1. Stage 0 (now, zero cost): don’t spend money. Ground myself with the free CS 7646 course + read two free papers, Harvey & Liu’s Backtesting and Bailey & López de Prado’s Probability of Backtest Overfitting, to build the muscle memory of “the returns I backtest are most likely fake.”
  2. Stage 1 (months 3–6): Grind through Jansen’s 3rd edition, run its crypto-perp funding-rate case end to end; read Chan to calibrate small-capital realism.
  3. Stage 2 (months 6–12, paper trading): Dry-run 1–2 of my own ideas on Freqtrade for at least 3–6 months, self-check with DSR, and only then touch real money — with the first live trade capped at $100–200.
  4. Explicitly not doing: no EPAT ($5–8k, that’s 6–9× my principal; the ROI doesn’t work) or any paid alpha community; no high-leverage perps; no trusting any profit proof that’s only screenshots.

Level 5 pass bar: the strategy dry-runs for a full 3–6 months, stays significant after DSR correction, and you invest no more than 5% of principal. And — you can calmly say, “I will most likely fail, but I’m paying for a skill, not buying a lottery ticket.”

7. The Complete Roadmap in One Picture

1
2
3
4
5

Level 1  Python data stack (NumPy/pandas)          2 weeks   Literacy
Level 2  JupyterLab research workflow              2 weeks   Main battlefield
Level 3  vectorbt + Plotly strategy discovery      1-2 mo    Brain
Level 4  Backtest bias + WFO + DSR statistics      3-6 mo    The watershed ★
Level 5  Execution + real-alpha path & ceiling     6-12 mo   Hands

Four pieces of advice for anyone who wants to get started:

  1. The order cannot be scrambled. Learning execution before validation is paying tuition with real money. Level 4 is the watershed; everything before it is preparation.
  2. Chinese tutorials are crutches, not staples. Good ones exist (Joyful Pandas), but the deepest material (López de Prado, the DSR paper) is English-only. English reading ability is itself the entry fee.
  3. Your first strategy is very likely wrong, and that’s normal. My first strategy (15m naked mean reversion) was falsified by me; the second (Martingale grid) was falsified by math; the third (MacdCross-4h) barely survived to the WFO final review. A quant researcher’s growth is built from the corpses of falsified strategies.
  4. Separate “teaches methods” from “promises profits.” Every legitimate resource (CS 7646, WQU, Jansen, Chan, López de Prado, Freqtrade) teaches only the former; everything claiming the latter is a grift. The Brazilian whole-market data says that of day traders who persisted 300 days, 97% lost money and only 0.4% beat minimum wage — accept this probability before you enter, then decide whether to spend those hundreds of hours.

This series:

All tutorial links in this post were verified by actual visits (2026-09); anything unverifiable was excluded — better to omit than to include junk. The code lives locally at /home/li/lynxcrypto, with all 107 tests green.