We're all works in progress. ↓ This is mine. ↓ TensorThrottleX Space ↓ Where unfinished ideas are allowed to evolve.

nowhere
Joined April 2025
I've wasted enough nights watching my potential slowly erode. -Enough distractions. -Enough broken promises to myself. -Enough comfort. -Enough excuses. The gap between who I am and who I want to become has grown unacceptable. Even through life's unavoidable challenges; health issues, unexpected setbacks, or periods of stillness; it remains deeply disappointing to recognize your true capabilities yet consistently fall short of them. This is a battle with myself. Today, I draw the line. For the next 30 days(keeping it short intentionally), there will be no debate, no negotiation, and no waiting for motivation. -This is not a challenge. -Not a trend. -Not a public commitment made for accountability. Each day must leave a mark: -A body pushed beyond its comfort zone. -A mind sharpened through deliberate, focused learning. -Something meaningful built that did not exist the day before. That's enough. This is not about inspirational threads or performative productivity. It is not about seeking validation or chasing fleeting approval. It is about evidence, quiet, consistent, undeniable evidence. Because a man is not defined by his plans or late-night intentions. He is defined by what he accomplishes when the initial excitement fades and the real work remains. Starting from tomorrow, I am no longer interested in proving anything to anyone. This is me and me alone. Just an honest confrontation between who I am and who I am capable of becoming.
3
1
1
13
872
POTD : THE RAW EMBEDDING LOOKUP Piece of Cake @TrenTorch
2
1
4
340
One of the best websites to visualize and learn ML. Someone implemented ML algorithms and derived them from first principles in Jupyter Notebooks and NumPy. Github: github.com/gavinkhung/machin… website: ml-visualized.com/index.html
6
95
576
20,461
Physical progress log 26 : Cardio : 3.47 km Legs done : ✅
1
123
Evening log : -from predicting residuals, fitting regression trees, computing the leaf values (γ), updating the log-odds, and converting everything back to probabilities. -Built a simplified implementation from scratch and compared it with sklearn.GradientBoostingClassifier to
1
4
433
Physical progress log 25 : Cardio: 4 km ✅ Chest, triceps ✅
1
3
101
Evening log : -Built and inspected the first regs- tree that learns the pseudo-residuals, then printed its complete tree structure to see exactly how the split threshold and leaf values are chosen. -Visualized the residuals in 3D and traced how each terminal node computes its own γ (leaf value) before updating the model prediction with the learning rate. It made the update rule much more intuitive than just reading the eqs.
3
479
Physical progress log 24 : Cardio: 4 km ✅ Weight training: Squats: 3×12 Hack Squats: 3×12 Hamstring Curls: 3×12 Walking Lunges:3×20 Standing Calf Raises: 3×40 Burpees: 3×15
1
73
Evening log : spent time reading through a complete implementation, comparing it with my own code, and seeing how modern GBM libraries organize everything into separate components like data preprocessing, tree growing, and the main boosting loop. the math stays the same, but real implementations are designed to be modular, reusable, and easy to scale. features like learning rate, tree depth, regularization, and sampling strategies aren't just hyperparameters they're built into the architecture from the ground up.
3
610
Evening log : Understanding the math that makes Gradient Boosting work : -instead of jumping straight into trees, i started with the MSE loss function and derived it step by step. one thing i found pretty cool is that when you differentiate the loss, the gradient simplifies to (ŷ − y). taking the negative gradient gives (y − ŷ), which is literally the residual. -that's the moment . Gradient Boosting isn't randomly fitting new trees it trains every new tree to predict the negative gradient of the loss. for MSE, that -ve gradient just happens to be the residuals, which is why every new tree is simply trying to fix the mistakes made by the current model. lowkey, deriving the eq. yourself instead of memorizing "fit on residuals" makes the entire algo feel way more intuitive.
1
3
708
Evening progress log 30 : Gradient Boosting works with L1 (MAE) loss: Instead of training each new tree on the actual residual values, Gradient Boosting uses the sign of the residuals (+1, -1, or 0), which represents the direction in which the model should move. Even though the regression tree is trained using Mean Squared Error (MSE) to find the best splits, the leaf values are later updated using the median of the residuals, making the overall algorithm optimize L1 loss. This helped me realize an important idea in Gradient Boosting: the way a tree is trained and the objective the entire boosting algorithm optimizes don't always have to be the same.
4
386
nobody talks about the boring part: - showing up every day. sitting on that damn chair. - doing the same work. repeating the same process. - but fck it, we ball. - today has one job: finish the checkpoints your yesterday self decided on. - stay disciplined.
8
4
1
111
5,252
Ayush retweeted
Day 11/90 of Inference Engineering How does vLLM work and how is it used in production? Before we discuss how vLLM works internally, it helps to understand what vLLM is. At a high level, vLLM is an inference engine that is designed to serve LLMs to thousands of concurrent users efficiently while managing scarce compute and memory. The goal for vLLM is to maximize throughput and minimize latency; optimizing for the best inference economics and experience for end users. With every request from the end user, it eventually ends up in the engine core, gets scheduled alongside other requests from other concurrent users, executes on the GPU, and updates the KV cache with the new key and value vectors, and streams the tokens back to the user. The Scheduler decides what requests should execute next while continuously batching requests together to maximize GPU utilization. Continuous batching is an inference optimization that allows new requests to join a running batch as other requests finish generating tokens. This helps with keeping the GPU utilization high instead of letting it sit idle waiting for an entire batch to complete generating. After the scheduler dispatches the selected batch to the Model Executor, the Model Executor prepares the tensors and metadata required for inference, retrieves each request’s block table from KV Cache Manager, launches the optimized transformer forward pass on the GPU, computes the logits, updates the KV cache with the new key and value vectors, and finally returns the results for sampling and streaming. The KV Cache Manager uses the PagedAttention memory layout to allocate fixed-size cache blocks on demand and maintains a Free Block Queue on the CPU that tracks which blocks in the GPU’s Paged KV Cache are currently free. When a request needs additional KV cache space, the KV Cache manager takes a free block from the queue and assigns it to that request, thus avoiding an expensive search through GPU memory for available cache blocks. All of these components form the core of vLLM’s inference engine. The Scheduler determines what requests are executed, the Model Executor determines how those requests are executed, the KV Cache Manager determines where each request’s KV cache lives using the PagedAttention Memory Layout. This architecture enables vLLM to serve thousands of concurrent requests with high throughput, low latency, and efficient GPU memory utilization. Heres a little animation that visualizes everything! - I've also completed the forward pass for my mnist.c project. I had a nice chat with @shreybirmiwal, such a knowledgeable guy. Excited to learn more about vLLM and implement a tiny-vLLM one day.
31
99
2
1,300
71,195
Physical progress log 23 : Cardio : done Legs: done
1
99
Evening progress log 29 : today i explored how Gradient Boosting changes when we switch from MSE to MAE loss. one thing i found really interesting is that they don't even train on the same targets. MSE-based GBMs train each tree on the actual residual values, while MAE-based GBMs only train on the sign of the residuals (+1 or -1). becuz they're learning from completely different targets, the trees end up grouping the data in different ways. - another cool difference is how the leaf values are calculated. both models eventually predict residual-like updates, but MSE uses the mean (average) of the residuals inside each leaf, whereas MAE uses the median. it seems like a tiny change, but it completely changes how the model updates itself. - the biggest info was why MAE is so much better with outliers. since it relies on the median, one extreme value (like a rent of 2000) barely affects the prediction, so the model stays focused on the normal data. with MSE, that same outlier pulls the mean way up, causing the model to chase that single unusual point instead of learning the overall pattern. lowkey a small mathematical change, but it has a huge impact on how the model behaves.
1
310
Ayush retweeted
A directory of ui skills for design engineers. Link : ui-skills.com
43
303
9
3,938
526,912
Evening log 28 : - went down a pretty interesting rabbit hole today about L1 vs L2 loss in Gradient Boosting. turns out L2 can get distracted by a few crazy outliers because squaring the error makes them look way more important than everything else. - with L1 loss, the model plays it much safer by using the median instead of the mean inside each tree. it doesn't panic over a few weird data points, so the updates stay much more stable. honestly, seeing how just changing the loss function completely changes the model's behavior was kinda wild.
3
272
Physical progress log 21 : Cardio : 4 km - done Workout : chest and shoulders -done
2
100
Evening log 27 : -spent today understanding how a Gradient Boosting Classifier is put together in code. the Kaggle notebook walks through the entire training process from the initial log-odds prediction, converting it into probabilities, calculating residuals, training a new decision tree, updating the leaf values, and repeating the same cycle until the final ensemble is built. -it also compares the custom implementation with scikit-learn's version using decision boundary plots. seeing both models produce almost the same decision regions made it much easier to connect the theory with the actual implementation. lowkey one of those moments where the code and the math finally started speaking the same language.
5
1,166
This GitHub repo is a goldmine if you want to deeply understand AI/ML, not just use it. Maths, CS & AI Compendium. Free. Henry filled notebooks for years with intuition-first, no fluff explanations while working in AI/ML. Friends used them to prep for DeepMind, OpenAI, Nvidia interviews. All got in. Now it's public. 20 chapters from vectors to bleeding-edge AI. Written with intuition first, real-world context, no hand-waving. Not written to survive an exam. Written to actually understand the stuff. What's covered: → Maths foundations - vectors, matrices, calculus, statistics, probability → Classical ML through distributed training and RL → Computational linguistics - transformers, attention, MoE, SSMs, LLM architectures → Computer vision - diffusion, flow matching, ViTs, SLAM, VR/AR → Audio & speech - ASR, TTS, WaveNet, Conformer, diarisation, source separation → Multimodal learning - CLIP, VLMs, image/video tokenisation, world models → Autonomous systems - VLAs, self-driving cars, space robots → SIMD & GPU programming - CUDA, Triton, ARM NEON, AVX, TPUs, WebGPU → AI inference - quantisation, speculative decoding, edge inference, cost optimisation → ML systems design - feature stores, A/B testing, recommendation, search, ads, fraud → Graph neural networks - geometric deep learning, 3D equivariant networks Only needs elementary maths and basic Python to start. MCP server included - Claude Code, Cursor, VS Code can use it as a knowledge base. Here's the GitHub Repo: github.com/HenryNdubuaku/mat…
9
121
1
599
26,529