1. Introduction
  3. Getting Started
  4. Installation
  5. Quick Start
  6. First Training Loop
  7. Core Concepts
  9. Architecture
  10. Overview
  11. Design Philosophy
  12. Module Organization
  13. Type System
  14. Memory Management
  16. Autograd Engine
  17. What is Automatic Differentiation?
  18. Tape-Based Computation Graphs
  19. Tensor Operations
    1. Matrix Multiplication
    2. Activations (ReLU, GELU, Swish)
    3. Layer Normalization
    4. Attention Mechanism
  21. Backward Pass
  22. Gradient Computation
  23. Finite Difference Validation
  25. Optimizers
  26. Overview
  27. Stochastic Gradient Descent (SGD)
  28. Adam Optimizer
  29. AdamW (Decoupled Weight Decay)
  30. Learning Rate Schedulers
    1. Cosine Annealing
    2. Step Decay
    3. Exponential Decay
  32. Gradient Clipping
  33. SIMD-Accelerated Updates
  34. Optimizer Theory
  36. LoRA (Low-Rank Adaptation)
  37. What is LoRA?
  38. Parameter-Efficient Fine-Tuning
  39. LoRA Layer Architecture
    1. Low-Rank Matrices A and B
    2. Scaling Factor (alpha/rank)
    3. Merge and Unmerge
  41. Target Module Selection
  42. Gradient Flow Isolation
  43. Adapter Persistence
    1. Saving Adapters
    2. Loading Adapters
    3. Sharing Adapters
  46. QLoRA (Quantized LoRA)
  47. Memory-Efficient Fine-Tuning
  48. 4-bit Quantization
    1. Block-Wise Quantization
    2. Scale Factors
    3. Quantization/Dequantization
  50. QLoRA Layer
  51. On-the-Fly Dequantization
  52. Memory Benchmarks
    1. LoRA vs QLoRA Comparison
    2. Transformer Model Benchmarks
    3. Compression Ratios
  54. Trade-offs and Best Practices
  56. Model Merging
  57. Overview
  58. TIES Algorithm
  59. DARE Algorithm
  60. SLERP Algorithm
  61. Multi-Model Ensembles
  62. Merge Best Practices
  64. Knowledge Distillation
  65. What is Distillation?
  66. Temperature-Scaled KL Divergence
  67. Multi-Teacher Ensemble
  68. Progressive Layer-Wise
  69. Distillation Loss Functions
  70. Student-Teacher Architecture
  72. Training Loops
  73. Trainer API
  74. Callback System
  75. Train Config
  76. Basic Training Loop
  77. Batching and Data Loading
  78. Loss Functions
  79. Validation and Testing
  80. Checkpointing
  81. Early Stopping
  82. Curriculum Learning
  83. Explainability
  85. Real-Time Monitoring
  86. Overview
  87. Experiment Tracking
  88. Quality Gates (Jidoka)
  89. Metrics Collection
  90. Terminal Dashboard
  91. Drift Detection
  92. Andon Alerting (Jidoka)
  93. Inference Monitoring
  94. Model Lineage
  95. Export Formats
  96. Hansei Reports
  98. Dashboard
  99. Overview
  100. DashboardSource Trait
  101. WASM Bindings
  103. Ecosystem Integration
  104. Overview
  105. Batuta Integration
  106. Realizar GGUF Export
  107. Ruchy Session Bridge
  109. MLOps (Toyota Way)
  110. Overview
  111. Experiment Tracking
  112. Preflight Validation (Jidoka)
  113. Model Registry (Kanban)
  114. Hyperparameter Optimization (Kaizen)
  115. Differential Privacy
  116. GPU Monitoring (Andon)
  117. REST API Server
  118. Cloud Storage
  119. LLM Evaluation
  121. Model I/O
  122. Overview
  123. Save Models
  124. Load Models
  125. Model Metadata
  126. Supported Formats
    1. SafeTensors Format
    2. JSON Format
    3. YAML Format
    4. GGUF Format
  129. Command-Line Interface
  130. CLI Overview
  131. Research Commands
  132. Benchmark Commands
  133. Inspect Command
  134. Audit Command
  135. Monitor Command
  136. Completion Command
  138. Declarative Training
  139. Overview
  140. YAML Mode Training (v1.0)
  141. YAML Examples Catalog
  142. Toyota Way QA Process
  143. YAML Configuration
  144. train_from_yaml Function
  145. Configuration Schema
  146. Optimizer Builders
  147. Model Builders
  149. API Reference
  150. Tensor API
  151. Autograd Operations
  152. Optimizer API
  153. LoRA API
  154. QLoRA API
  155. Configuration System
  156. Error Handling
  158. Examples
  159. Linear Regression with Autograd
  160. Training a Simple MLP
  161. Fine-Tuning with LoRA
  162. Memory-Efficient QLoRA
  163. Custom Loss Functions
  164. Learning Rate Scheduling
  165. Gradient Clipping
  166. Adapter Sharing
  167. CUDA Backend Configuration
  169. Development Guide
  170. Contributing
  171. EXTREME TDD Methodology
  172. Testing Strategy
    1. Unit Tests
    2. Property-Based Tests
    3. Gradient Checking Tests
    4. Mutation Testing
  174. Quality Gates
    1. Pre-Commit Hooks
    2. Continuous Integration
    3. Code Coverage
    4. Clippy Linting
  176. Benchmarking
  177. PMAT Toyota Workflow
  179. Best Practices
  180. Optimizer Selection
  181. Learning Rate Tuning
  182. LoRA Configuration
  183. Memory Optimization
  184. Gradient Stability
  185. Debugging Training Issues
  186. Performance Profiling
  188. Search Algorithms
  189. Overview
  190. Monte Carlo Tree Search (MCTS)
    1. State and Action Spaces
    2. UCB1/PUCT Selection
    3. Expansion and Simulation
    4. Backpropagation
  192. Policy Network Integration
  194. Generative Models
  195. Overview
  196. Code Generation GANs
    1. Generator Architecture
    2. Discriminator Architecture
    3. Latent Space Interpolation
    4. Training Loop
  198. Mode Collapse Detection
  200. Advanced Topics
  201. Custom Backward Passes
  202. Implementing New Optimizers
  203. Custom LoRA Variants
  204. Advanced Quantization
  205. Distributed Training
  206. Model Parallelism
  207. Compiler-in-the-Loop (CITL)
  209. Sovereign Deployment
  210. Overview
  212. Academic Research
  213. Overview
  215. Specifications
  216. Autograd Specification
  217. Optimizer Specification
  218. LoRA Specification
  219. Quantization Specification
  220. Academic Foundations
  222. Appendix
  223. Glossary
  224. Mathematical Notation
  225. References
  226. FAQ
  227. Changelog
  228. Migration Guide
  229. Benchmarking Results