1. Introduction
3. Getting Started
4. 1. Installation
5. 2. Quick Start
6. 3. First Training Loop
7. 4. Core Concepts
9. Architecture
10. 5. Overview
11. 6. Design Philosophy
12. 7. Module Organization
13. 8. Type System
14. 9. Memory Management
16. Autograd Engine
17. 10. What is Automatic Differentiation?
18. 11. Tape-Based Computation Graphs
19. 12. Tensor Operations
20. 1. 12.1. Matrix Multiplication
    2. 12.2. Activations (ReLU, GELU, Swish)
    3. 12.3. Layer Normalization
    4. 12.4. Attention Mechanism
21. 13. Backward Pass
22. 14. Gradient Computation
23. 15. Finite Difference Validation
25. Optimizers
26. 16. Overview
27. 17. Stochastic Gradient Descent (SGD)
28. 18. Adam Optimizer
29. 19. AdamW (Decoupled Weight Decay)
30. 20. Learning Rate Schedulers
31. 1. 20.1. Cosine Annealing
    2. 20.2. Step Decay
    3. 20.3. Exponential Decay
32. 21. Gradient Clipping
33. 22. SIMD-Accelerated Updates
34. 23. Optimizer Theory
36. LoRA (Low-Rank Adaptation)
37. 24. What is LoRA?
38. 25. Parameter-Efficient Fine-Tuning
39. 26. LoRA Layer Architecture
40. 1. 26.1. Low-Rank Matrices A and B
    2. 26.2. Scaling Factor (alpha/rank)
    3. 26.3. Merge and Unmerge
41. 27. Target Module Selection
42. 28. Gradient Flow Isolation
43. 29. Adapter Persistence
44. 1. 29.1. Saving Adapters
    2. 29.2. Loading Adapters
    3. 29.3. Sharing Adapters
46. QLoRA (Quantized LoRA)
47. 30. Memory-Efficient Fine-Tuning
48. 31. 4-bit Quantization
49. 1. 31.1. Block-Wise Quantization
    2. 31.2. Scale Factors
    3. 31.3. Quantization/Dequantization
50. 32. QLoRA Layer
51. 33. On-the-Fly Dequantization
52. 34. Memory Benchmarks
53. 1. 34.1. LoRA vs QLoRA Comparison
    2. 34.2. Transformer Model Benchmarks
    3. 34.3. Compression Ratios
54. 35. Trade-offs and Best Practices
56. Model Merging
57. 36. Overview
58. 37. TIES Algorithm
59. 38. DARE Algorithm
60. 39. SLERP Algorithm
61. 40. Multi-Model Ensembles
62. 41. Merge Best Practices
64. Knowledge Distillation
65. 42. What is Distillation?
66. 43. Temperature-Scaled KL Divergence
67. 44. Multi-Teacher Ensemble
68. 45. Progressive Layer-Wise
69. 46. Distillation Loss Functions
70. 47. Student-Teacher Architecture
72. Training Loops
73. 48. Trainer API
74. 49. Train Config
75. 50. Basic Training Loop
76. 51. Batching and Data Loading
77. 52. Loss Functions
78. 53. Validation and Testing
79. 54. Checkpointing
80. 55. Early Stopping
82. Real-Time Monitoring
83. 56. Overview
84. 57. Metrics Collection
85. 58. Terminal Dashboard
86. 59. Drift Detection
87. 60. Andon Alerting (Jidoka)
88. 61. Model Lineage
89. 62. Export Formats
90. 63. Hansei Reports
92. Model I/O
93. 64. Overview
94. 65. Save Models
95. 66. Load Models
96. 67. Model Metadata
97. 68. Supported Formats
98. 1. 68.1. JSON Format
    2. 68.2. YAML Format
    3. 68.3. GGUF Format
100. Command-Line Interface
101. 69. CLI Reference
103. Declarative Training
104. 70. Overview
105. 71. YAML Configuration
106. 72. train_from_yaml Function
107. 73. Configuration Schema
108. 74. Optimizer Builders
109. 75. Model Builders
111. API Reference
112. 76. Tensor API
113. 77. Autograd Operations
114. 78. Optimizer API
115. 79. LoRA API
116. 80. QLoRA API
117. 81. Configuration System
118. 82. Error Handling
120. Examples
121. 83. Linear Regression with Autograd
122. 84. Training a Simple MLP
123. 85. Fine-Tuning with LoRA
124. 86. Memory-Efficient QLoRA
125. 87. Custom Loss Functions
126. 88. Learning Rate Scheduling
127. 89. Gradient Clipping
128. 90. Adapter Sharing
130. Development Guide
131. 91. Contributing
132. 92. EXTREME TDD Methodology
133. 93. Testing Strategy
134. 1. 93.1. Unit Tests
     2. 93.2. Property-Based Tests
     3. 93.3. Gradient Checking Tests
     4. 93.4. Mutation Testing
135. 94. Quality Gates
136. 1. 94.1. Pre-Commit Hooks
     2. 94.2. Continuous Integration
     3. 94.3. Code Coverage
     4. 94.4. Clippy Linting
137. 95. Benchmarking
138. 96. PMAT Toyota Workflow
140. Best Practices
141. 97. Optimizer Selection
142. 98. Learning Rate Tuning
143. 99. LoRA Configuration
144. 100. Memory Optimization
145. 101. Gradient Stability
146. 102. Debugging Training Issues
147. 103. Performance Profiling
149. Advanced Topics
150. 104. Custom Backward Passes
151. 105. Implementing New Optimizers
152. 106. Custom LoRA Variants
153. 107. Advanced Quantization
154. 108. Distributed Training
155. 109. Model Parallelism
157. Specifications
158. 110. Autograd Specification
159. 111. Optimizer Specification
160. 112. LoRA Specification
161. 113. Quantization Specification
162. 114. Academic Foundations
164. Appendix
165. 115. Glossary
166. 116. Mathematical Notation
167. 117. References
168. 118. FAQ
169. 119. Changelog
170. 120. Migration Guide
171. 121. Benchmarking Results