This is my pinned tweet until I tweet a banger

STOP telling your employer that they can call you on your personal phone anytime if needed. You are just fanning the toxic culture. Especially the Indian startups.

Is it just me or the streaming on this app is really fkd up? Even the TL loading is pathetic. @elonmusk fix it ASAP.

Stochastic Gradient Descent (SGD) is the basic optimizer most deep learning training is built on. Instead of calculating the gradient on the entire dataset (which is slow and memory-heavy), SGD computes the gradient on a small random batch of examples and updates the weights immediately. It repeats this many times. The update is simple: move the weights a small step in the opposite direction of the gradient. The size of the step is controlled by the learning rate. Why it works: even though each update is noisy, over many steps the noise averages out and the model moves toward lower loss. The randomness can also help it escape shallow local minima. However, it has some drawbacks: - It is sensitive to the learning rate. Too high and training diverges. Too low and it crawls. - Progress can be slow and unstable, especially on loss surfaces with steep and flat directions. - It treats every parameter the same, which is inefficient when some weights need bigger updates than others. - Without additions like momentum, it tends to oscillate. Plain SGD is rarely used alone anymore. Most people use SGD with momentum or switch to adaptive methods like AdamW. Still, understanding SGD matters because almost every other optimizer is a modification of this basic idea.

Triplet loss is a way to train models so that similar things end up close together and different things end up far apart. You feed the model three examples at a time: - an anchor (the reference) - a positive (something that should be similar to the anchor) - a negative (something that should be different) The loss pushes the anchor and positive closer in the embedding space while pushing the anchor and negative farther apart, usually by at least some margin. It’s commonly used in: - face recognition - image retrieval - recommendation systems - any task where you care about similarity rather than exact class labels The basic idea is simple: don’t just learn to classify. Learn a space where distance means something useful.

I swear if they fire me I'll spill all the beans what's happening at Microsoft India. Don't force me.

Linkedin you sicko

If I was Michael Carrick, I would start doing LeetCode again. #MUFC

If you are developing with cursor, the X plus subscription is totally useless for you.

X users in India. Please be careful. X is showing subscription amount in ₹ for Plus and in $ for Ultra. This is so devious. Someone might look at the number and choose ultra thinking it's cheaper. @X fix it.

Be mindful of your loss functions. They can make all the difference between cats and dogs. #deeplearning

Learn linear algebra. Go under debt if you have to.

Learn calculus, people. It improves sleep.

Most machine learning models learn correlations. Causal inference tries to go further and learn what actually causes what. A normal model can tell you that ice cream sales and drowning incidents both rise in summer. It cannot tell you that ice cream doesn’t cause drowning. Causal methods try to answer questions like “what would happen if we changed this?” instead of just “what usually happens together?” Representation learning is about turning raw data into useful features. When you combine the two, the goal is to learn representations that capture the underlying causal structure, not just surface-level patterns. Why this matters: - Models that only learn correlations often fail when the world changes. - Causal representations can be more robust and more interpretable. - They help with questions like “if we intervene on X, what happens to Y?” It’s still an active research area, but the basic idea is simple: stop only asking what predicts what, and start asking what causes what.

Hot take: All these companies laying off employees in huge numbers will crawl back to them in a few months and hire them at twice the current salaries.

Accepted cookies on a website to download free movies

Langchain or "I don't need a framework, I know what I'm doing" ??

Self-supervised learning is a way for models to learn useful patterns from data without human labels. Instead of giving the model correct answers, you create a task from the data itself. The model has to solve that task, and in the process it learns representations that are useful for real problems later. A few common approaches: - Predict the missing part. Hide some words in a sentence or some patches in an image and train the model to fill them in. - Contrastive learning. Show the model two versions of the same thing (e.g. two crops of the same image) and teach it that they should be similar, while different things should be dissimilar. - Predict the next token or next frame. This is how most large language models and some video models are pretrained. Why it matters: labeling data is expensive and slow. Self-supervised learning lets you use huge amounts of raw text, images, or audio. The representations it learns often transfer well to downstream tasks with only a little labeled data. It’s one of the main reasons modern models can be trained at such large scale.