DEV Community: Ma Uttaram

Life Cycle of Training

Ma Uttaram — Fri, 08 May 2026 15:43:06 +0000

Here is the standard "Life Cycle" of a single training step:

1. Forward Pass (The Guess)

Linear: $z = w \cdot x + b$
Activation: $a = f(z)$ (ReLU, Sigmoid, etc.)
This happens layer by layer until you get a final prediction.

2. Loss Calculation (The Error)

You compare the prediction to the Actual Target.
Cross-Entropy: Used for classification (e.g., "Is this a cat or a dog?").
MSE (Mean Squared Error): Used for regression (e.g., "What is the price of this house?").

3. Backpropagation (The Blame)

You calculate the Gradients.
This tells you exactly how much each weight ($w$) and bias ($b$) contributed to the error.

4. Optimization (The Fix)

You use Gradient Descent to slightly nudge the weights in the direction that reduces the Loss.
$w = w - (\text{learning rate} \cdot \text{gradient})$

Layer 1 (Weighted SUM -> Activation Function) ->Layer 2 (Weighted SUM -> Activation Function)

get output passing input via the layers for Neural networks

🏁 Summary

Forward (Guess) --> Loss (Check) --> Backward (Assign Blame) --> Optimizer (Update).
To keep going, do you want to:

See how Cross-Entropy math actually works?
Understand the difference between Weights and Biases in the update step?

Linear Algebra

Ma Uttaram — Fri, 08 May 2026 11:47:33 +0000

Linear Regression

The Math: (y = Xw + b)

The Loop:

Use Gradient Descent.Predict (y_{pred}).Calculate Error ((y_{pred} - y_{true})).

Compute Gradient:

(X^T \cdot \text{Error} / n).Update Weights: (w = w - (\text{learning_rate} \times \text{gradient})).

Logistic RegressionThe Difference:

Same as Linear Regression, but pass the result through the Sigmoid Function: (1 / (1 + e^{-z})).

The Goal:

Maps any number to a probability between 0 and 1.

K-Means

The Logic:

Pick (k) random points as "centroids."Assign every data point to the nearest centroid.Move centroids to the average of their assigned points.Repeat until the centroids stop moving.

Impute+Encoding+Scaling+Hyperparam tuning

Ma Uttaram — Fri, 08 May 2026 11:41:36 +0000

Data Cleaning & Feature EngineeringImputation:

Don't just delete missing values; fill them with the median or use a KNN

imputer.Encoding:

Use One-Hot Encoding for categories with no order (colors) and Label Encoding for order (sizes like S, M, L).

Scaling:

Always use StandardScaler or MinMaxScaler for SVMs and Linear models; otherwise, large numbers will "bully" small ones.

Hyperparameter TuningGrid Search:

Tests every possible combination (Slow but thorough).Random Search: Tests random combinations (Faster, often just as good).Bayesian Optimization: Uses math to "guess" which parameters will work best next based on previous results.

XBoost+Random Forest+SVM

Ma Uttaram — Fri, 08 May 2026 11:38:55 +0000

🌲 Random Forest (The Stable One)

Imagine asking 100 people a "Yes/No" question and taking the majority vote. That is Random Forest.

Concept: It creates a "Forest" of many Decision Trees. Each tree is trained on a random subset of the data and a random subset of the features.
The "Stability" Factor: Because it averages the results of many trees, one "bad" or "weird" tree can't ruin the final prediction.
Best For: When you want a model that "just works" without hours of tuning. It is very hard to break and handles messy data (outliers) beautifully.

🚀 Gradient Boosting (The "King")

If Random Forest is a group of people voting simultaneously, Gradient Boosting is a team of students learning from their mistakes.

Concept: It builds trees one after the other (sequentially). Tree #1 makes a guess. Tree #2 focuses only on the errors Tree #1 made. Tree #3 focuses on the errors left over by Tree #2.
The "King" Status: Algorithms like XGBoost or LightGBM are incredibly fast and precise. They win almost every competition for structured data because they can find very complex patterns.
Catch: They are prone to overfitting if you don't tune the hyperparameters (the "knobs") correctly.

🛣️ Support Vector Machines (The "Widest Street")

SVM is about finding the cleanest possible boundary between two groups.

Concept: It doesn't just draw a line; it looks for the Maximum Margin. It tries to create the widest possible "neutral zone" (the street) between classes.
The Kernel Trick: Sometimes, data points are so mixed up in 2D that you can't draw a line between them. SVM uses math to "lift" the data into 3D space. Suddenly, you can slide a flat sheet of paper (a hyperplane) between the groups. When you project it back down to 2D, that flat sheet looks like a perfect circular or curved boundary.
Best For: Smaller, clean datasets where you need high precision (like medical diagnosis or image recognition).

💡 Summary Comparison

Algorithm	Strategy	Main Strength
Random Forest	Voting in parallel	Reliability; hard to mess up.
Gradient Boosting	Learning in sequence	Pure power; highest accuracy.
SVM	Geometric separation	High precision in complex spaces.

These three algorithms represent the "Top Tier" of traditional Machine Learning. Most professional data science projects for tabular data (Excel-style data) use one of these.

🌲 Random Forest (The Stable One)

Imagine asking 100 people a "Yes/No" question and taking the majority vote. That is Random Forest.

Concept: It creates a "Forest" of many Decision Trees. Each tree is trained on a random subset of the data and a random subset of the features.
The "Stability" Factor: Because it averages the results of many trees, one "bad" or "weird" tree can't ruin the final prediction.
Best For: When you want a model that "just works" without hours of tuning. It is very hard to break and handles messy data (outliers) beautifully.

🚀 Gradient Boosting (The "King")

If Random Forest is a group of people voting simultaneously, Gradient Boosting is a team of students learning from their mistakes.

Concept: It builds trees one after the other (sequentially). Tree #1 makes a guess. Tree #2 focuses only on the errors Tree #1 made. Tree #3 focuses on the errors left over by Tree #2.
The "King" Status: Algorithms like XGBoost or LightGBM are incredibly fast and precise. They win almost every competition for structured data because they can find very complex patterns.
Catch: They are prone to overfitting if you don't tune the hyperparameters (the "knobs") correctly.

🛣️ Support Vector Machines (The "Widest Street")

SVM is about finding the cleanest possible boundary between two groups.

Concept: It doesn't just draw a line; it looks for the Maximum Margin. It tries to create the widest possible "neutral zone" (the street) between classes.
The Kernel Trick: Sometimes, data points are so mixed up in 2D that you can't draw a line between them. SVM uses math to "lift" the data into 3D space. Suddenly, you can slide a flat sheet of paper (a hyperplane) between the groups. When you project it back down to 2D, that flat sheet looks like a perfect circular or curved boundary.
Best For: Smaller, clean datasets where you need high precision (like medical diagnosis or image recognition).

💡 Summary Comparison

Algorithm	Strategy	Main Strength
Random Forest	Voting in parallel	Reliability; hard to mess up.
Gradient Boosting	Learning in sequence	Pure power; highest accuracy.
SVM	Geometric separation	High precision in complex spaces.

Data Science Phase1

Ma Uttaram — Fri, 01 May 2026 19:09:39 +0000

Phase 1: The Engine (Linear Algebra)

The Goal: Moving and transforming data.
Key Formula: $y = Wx + b$
$x$ (Input Vector): Your raw data (e.g., $[7, 3]$ for Sleep and Coffee).
- $W$ (Weight Matrix): The "importance" values the AI gives each feature.
- $b$ (Bias): A baseline "nudge" (the score if sleep and coffee were zero).
Dot Product: Multiplying matching elements and summing them up. It measures similarity.
Matrix Multiplication: Running many students through the model at once. Rule: Order matters ($AB \neq BA$).

Phase 2: The Map (Geometry)

The Concept: A matrix is a transformation machine that warps space.
The Grid: The columns of your matrix are the "New Rulers." They tell you where the original axes land after the transformation.
The Determinant: The "Squash Factor."
$\text{Det} = 1$: Area stays the same.
- $\text{Det} = 0$: The 2D world collapses into a 1D line (information is lost).

Phase 3: The Skeleton (Eigen-Concepts)

Eigenvector: A special "direction" (profile) that never tilts during a transformation. It only gets longer or shorter.
Eigenvalue ($\lambda$): The number that tells you how much the eigenvector was stretched.
AI Insight: The eigenvector with the largest eigenvalue represents the most important trend in your data.
Characteristic Equation: $\det(A - \lambda I) = 0$. We subtract $\lambda$ diagonally to find the value that "collapses" the matrix.

Phase 4: The Steering Wheel (Calculus)

The Derivative: A sensor that detects if the Error goes up or down when you change a weight.
The Gradient ($\nabla$): A vector of all derivatives. It’s a compass pointing toward the "Mountain of Error."
Gradient Descent: The process of walking opposite the gradient to find the "Valley of Minimum Error."
Formula: $w_{new} = w_{old} - (\text{Learning Rate} \times \text{Gradient})$
Convergence: When the Gradient is zero, the AI has found the best possible weights.

Phase 5: The Gut Check (Probability)

Confidence: Measured by Standard Deviation ($\sigma$).
Low $\sigma$: The AI is "sure" (tight bell curve).
- High $\sigma$: The AI is "unsure" (wide bell curve).
Softmax: A formula that turns raw scores (like 10 and 2) into probabilities that add up to 100% (like 98% and 2%).
Bayes' Theorem: How the AI updates its "opinion" (Prior) when it sees new data (Likelihood) to get a new result (Posterior).

Quick-Reference Math Symbols:

$W$: Weights (The "Importance")
$\eta$ (Eta): Learning Rate (The "Step Size")
$\nabla$ (Nabla): The Gradient (The "Direction to fix")
$\lambda$ (Lambda): Eigenvalue (The "Strength of a trend")
$\det$: Determinant (The "Scaling/Squashing factor")

You’ve officially covered the "Big Five" of AI math! How does this summary look for your notes?

System Design - Part 4

Ma Uttaram — Thu, 30 Apr 2026 21:33:06 +0000

Strava

Online Auction

Facebook Live Video

Facebook Post Search

System Design - Part 3

Ma Uttaram — Fri, 17 Apr 2026 21:11:04 +0000

Facebook News Feed

Tinder

LeetCode

yelp

Rate Limiter

System Design - Part 2

Ma Uttaram — Fri, 17 Apr 2026 19:04:45 +0000

Uber

Robinhood
-- Key is the Number of requests from various IPs is not allowed so limit src Ips.

Google Docs

Distributed Cache

Youtube

System Design - Part 1

Ma Uttaram — Thu, 16 Apr 2026 19:49:43 +0000

News Feed Service

Drop Box

Tiny URL

Local Delivery Service

Ticket Master

DAG vs Langraph Nodes

Ma Uttaram — Sun, 29 Mar 2026 00:39:21 +0000

When we have DAG that represents our tasks and its dependencies do we still need Langraph nodes?

LangGraph nodes are most valuable when your flow has cycles — loops, retries, HITL resume, conditional branching back to earlier steps. A pure DAG has none of that, so LangGraph's core value proposition doesn't apply.

So are they mutually exclusive? No! They can complement each other. See the beautiful project to understand why.

LangGraph nodes for the orchestration layer: intent_parser → entity_extractor → plan_builder → hitl_plan → cot_builder → hitl_confirm. This is the stateful, cyclic part.

Your own DAG executor for task execution: takes the confirmed TaskGraph, runs a topological sort, fans out independent tasks with asyncio, collects results. Twenty to thirty lines of plain Python. No framework.

| Send API for parallel dispatch | LangGraph-native fan-out; no manual thread/asyncio management; results merged automatically |

The DAG (networkx) and LangGraph Send API solve different problems and are complementary — not alternatives. See the 'Why both networkx DAG and LangGraph Send API?' section added to the Overview. Short answer: networkx tells us WHAT to run (which steps are ready, via topological ordering and predecessor checks); LangGraph Send API handles HOW to run them concurrently (fan-out to parallel node invocations, automatic state merge on fan-in). You could replace Send with asyncio.gather inside a single node, but you'd lose per-step checkpointing (partial progress survives failures), automatic state merging, and consistency with the rest of the LangGraph pipeline.

Your mental model was almost right — let me clarify the full split:\n\n| Concern | Tool | Why |\n|---|---|---|\n| Dependency graph structure | networkx DAG | Planner builds it, CoT validator walks it, executor queries it for readiness |\n| Parallel task execution | LangGraph Send API | Fan-out ready steps as concurrent node invocations; LangGraph auto-merges results |\n| HITL + session resume | LangGraph interrupt() + PostgresSaver | Only LangGraph provides checkpointed pause/resume semantics |\n\nThe DAG is used across all pipeline stages — not just the executor — as a data structure for graph operations (cycle detection, topological sort, predecessor queries). LangGraph is the execution engine throughout. The executor uses both: DAG to decide which steps are ready, Send API to run them in parallel. Added a dedicated section in the executor design doc explaining this.

The DAG (networkx) is a data structure for representing and querying step dependencies — it lives in dag.py and is used by three different pipeline stages (planner for cycle detection, CoT validator for topological walk, executor for readiness checks). LangGraph graph nodes (validate_cot, execute_step, etc.) are the execution units in the agent runtime. They use the DAG as a utility library. There's no conflict — the DAG tells the LangGraph nodes what order/parallelism is required; LangGraph handles actually running them, checkpointing state, and managing HITL interrupts.

Langraph vs Langchain

Ma Uttaram — Sat, 28 Mar 2026 22:32:39 +0000

As I was working on HITL, I was checking to see if we can start with existing Agentic Frameworks like Langraph and Langchain. The below was very interesting

Evaluation Techniques

Ma Uttaram — Sat, 28 Mar 2026 20:07:01 +0000

There are six main evaluation techniques, falling into two broad families: those that compare against a known answer, and those that use judgment. Here's a visual overview, then the explanation of each.Here's each technique explained:

Exact match — the simplest form. You know the correct answer, and you check whether the output equals it exactly. Works well for structured tasks: intent classification ("is this a booking request?"), entity extraction where the expected output is a fixed JSON, or tool selection ("should the agent call the calendar API or the email API here?"). Brittle for open-ended text because two correct answers can be worded differently.

Schema / constraint validation — instead of checking exact values, you check the shape of the output. Does entity extraction return a valid Task schema with all required fields? Did the plan builder produce a properly ordered list? This is what Pydantic and Zod do, and it's directly relevant to BuddingBuilder's FR #7. It catches malformed outputs even when the content is hard to verify.

Code execution / unit test — the gold standard for any agent that produces code or structured plans. You run the output and check whether tests pass. For BuddingBuilder this applies to any task whose result is deterministically verifiable — a calculation, a formatted document, a database query result.

Reference-based LLM judge — you have a golden answer, and you ask a judge model to compare the agent's output against it and score the match. Returns a score and a reason. More flexible than exact match because it can handle paraphrasing, but requires you to maintain a library of golden examples, which takes effort to build and keep current.

Rubric-based LLM judge — no golden answer needed. You give the judge a scoring rubric ("rate this response 1–5 on correctness, task completion, and safety") and it evaluates the output on its own. This is the most practical technique for staging, because you can write rubrics faster than you can curate golden answers. The key is writing rubrics that are specific enough that the judge can't wriggle around them.

Pairwise preference — the judge sees two outputs side by side and picks the better one. You're not asking "is this good?" but "which is better — the old prompt or the new one?" This is the right technique for promotion gates: before moving from dev to staging, run pairwise eval between the new version and the current prod version. If the new version wins consistently, promote. This is also how RLHF preference data is collected.

Human eval — a human reads and rates the output. Highest signal, but too slow and expensive to run on everything. Its real job is to calibrate your automated judges — you periodically sample flagged traces, have a human rate them, and check whether your judge model's scores agree. If they don't, your rubric needs refining.

Online monitoring — the only technique running continuously in prod. The guard model scores inputs before the agent acts; the output validator scores responses after. Neither produces a detailed critique — they produce a fast pass/fail signal with enough metadata to route flagged interactions to the human review queue. This is what closes BuddingBuilder's prod → dev feedback loop.

claude.ai