Before we build anything, we need a clear mental model of what these architectures actually do — not the marketing version, the mechanistic one.

Time-Series Foundations: Transformers, Diffusion, and Why They're Different

How to align three different data sources into one consistent daily dataset — and why every alignment decision is also a leakage decision.

Data Pipeline: NASDAQ-100, Options Chain, and Sentiment

What each feature actually measures, why it might matter for predicting NASDAQ-100 returns, and how to compute it without accidentally injecting future information.

Feature Engineering: From OHLCV to a Rich Feature Matrix

We built it. We ran it. It predicted the same thing for every stock. Here's exactly what happened and what it reveals about applying transformers to financial data.

The Standard Transformer: Architecture, Training, and Why It Collapsed

The architecture that finally worked — and a precise explanation of why each component addresses a specific failure mode of the Standard Transformer on financial data.

Temporal Fusion Transformer: Gating, Memory, and Sector Learnability

The step most AI trading projects skip — and the reason most of them fail when they reach real capital. A rigorous validation framework for quantitative ML.

Validation Discipline: Catching Leakage, Rank IC, and the Economic Viability Wall

The model that finally survived adversarial validation — and why gradient boosting often beats deep learning on structured financial data.

LightGBM as Signal Engine: Feature Sets, Clean Candidates, and OOS Testing

A statistically real signal is not yet a tradeable system. This is the architecture that converts +0.08 Rank IC into a deployable paper-trading framework — and why the layers between prediction and profit are harder than the model itself.

System Architecture: Signal → Strategy → Execution

A practitioner's journey: from raw market data through Temporal Fusion Transformers, LightGBM, signal validation, and live trading architecture. All concepts defined, all mistakes documented.

Building a Quantitative Trading System — Series Index

What Actually Happens When Your Python Calls the GPU? — Part 2 of a Series

A hands-on journey from a single line of PyTorch code to the silicon on an NVIDIA GB10 Spark — tracing a matrix multiply through the full execution stack and profiling it with Nsight Systems.

What Actually Happens When Your Python Calls the GPU?

Configured inflight batching in TensorRT-LLM Triton backend for Llama 3 8B model, tuning parameters to optimize GPU utilization and balance latency and throughput under bursty loads.

Evaluating Inflight Batching and Scheduler Policies in TensorRT-LLM Triton Backend

Comparing AWQ INT4 and FP8 quantization methods on the Llama 3 70B model across accuracy benchmarks (MMLU, HumanEval, GSM8K, MT-Bench) and inference throughput measurements on an H100 GPU.

AWQ vs. FP8 Quantization: Balancing Accuracy and Throughput for Llama 3 70B

A complete setup guide for running Qwen 2.5 Coder locally via Ollama and connecting it to OpenCode, creating a private, offline-capable AI coding assistant in your terminal.

Running Qwen 2.5 Coder Locally with OpenCode: A Private AI Coding Assistant

Tuning speculative decoding using Llama 3 8B as the draft model and Llama 3 70B as the target to reduce decode latency.

Speculative Decoding Latency Optimization on TensorRT-LLM with Llama 3 Models

Using CUDA graph capture in TensorRT-LLM to eliminate kernel launch overhead during the decode phase of Llama 3 8B on RTX 4090 — benchmarks, trade-offs, and lessons learned.

CUDA Graph Capture for Low-Latency LLM Decode on RTX 4090

End-to-end TensorRT-LLM FP8 inference optimization on NVIDIA GB10 Blackwell from baseline to 3K+ tokens/sec was achieved through a series of phases.

End-to-End TensorRT-LLM FP8 Inference Optimization on NVIDIA GB10 Blackwell

Migrating from a single-account setup to a proper multi-account AWS landing zone with Organizations, Control Tower, Tailscale hybrid networking, centralized security, and cost guardrails — all built spec-first with Kiro.

Building Production ML Infrastructure on AWS with Kiro: Part 2 — Multi-Account Landing Zone

How we used Kiro's spec-driven workflow to go from a rough idea to fully deployed AWS network infrastructure across two environments — VPCs, NAT, CI/CD, and audit logging — in a single session.

Building Production ML Infrastructure on AWS with Kiro: Part 1 — Network Foundation

Built an automated content publishing pipeline using local LLMs that processes raw session notes into structured markdown and publishes them to a blog GitHub repository if they meet publishability criteria.

Automated Content Publishing Pipeline with Local LLMs

<h2 id="commands-used">Commands Used</h2>
<pre><code class="language-bash">python autoawq_quantize.py --model llama3-70b --bits 4 --group_size 128 --output ./llama3-70b-awq
python modelopt_quantize.py --model llama3-70b --dtype fp8 --calib_size 512 --output ./llama3-70b-fp8
lm_eval --model hf --model_args pretrained=./llama3-70b-fp8 --tasks mmlu,gsm8k --device cuda
python mt_bench_eval.py --model ./llama3-70b-awq --judge gpt-4
</code></pre>
<h2 id="lessons-learned">Lessons Learned</h2>
<ul>
<li>FP8 is the better choice when GPU supports it - near-lossless accuracy, 2x compression.</li>
<li>AWQ INT4 is best for memory-constrained deployment (38GB fits on single A100 40GB).</li>
<li>Never choose quantization method without evaluating on your target task distribution.</li>
<li>Mixed precision (FP8 weights, FP16 activations) is the safest starting point.</li>
</ul>
<h2 id="next-steps">Next Steps</h2>
<ul>
<li>Test GPTQ vs AWQ at INT4 on same benchmarks for completeness</li>
<li>Evaluate SmoothQuant as a middle ground between FP8 and INT4</li>
</ul>
