Math: Learn to Read It, Not Fear It

In Machine Learning, equations are easier when you stop looking at them as complicated math and start reading them like sentences.

Think of it this way:
Symbols are just words.
An equation is just a sentence made from those words.

Start With the Most Common Symbols

• x — the input or data given to the model.
  Example: age, height, temperature, pixels in an image, etc.
• y — the actual answer.
  This is what we already know to be correct.
• ŷ (y-hat) — the model's predicted answer.
  Think: "What did the model guess?"
• w — a weight.
  It tells the model how important an input should be.
• b — the bias.
  Think of it as an extra adjustable value that helps the model fit the data.
• θ (theta) — all of the model's adjustable parameters together.
  Usually this means the model's weights and biases.
• L or J — the loss/error.
  Think: "How wrong is the model?"
• α (alpha) — the learning rate.
  Think: "How big of a step should the model take while learning?"

Symbols That Tell Us What to Do

• Σ (sigma) — "add all of these."
  If the model makes many errors, Σ can tell us to add those errors together.
• ∇ (nabla) — the gradient.
  For now, read it as:"Which direction should the model change?"
  More precisely, it tells us how the loss changes when the model's parameters change.
• E[X] — the expected value.
  Think:"What average result should I expect if this happened many times?"
• argmax — "which choice gives me the biggest result?"
• argmin — "which choice gives me the smallest result?"
  In ML, we often use this idea because we want the parameters that give us the smallest loss.

Small Symbols Around Other Symbols

• x_i — the i-th item.
  If we have many values, the subscript tells us which one we are talking about.
  Example: x₁, x₂, x₃.
• x² — x multiplied by itself.
  Example: 5² = 5 × 5 = 25.
• x⁽ⁱ⁾ — usually means thei-th example in a dataset.
  The parentheses are important: this usually does notmean "x to the power of i."

Now Read an Equation Like a Sentence

Suppose you see:

ŷ = wx + b

Don't immediately think, "Oh no, math."

Translate each symbol:

• x = input
• w = importance of that input
• b = extra adjustment
• ŷ = prediction

So the equation is simply saying:

"Take the input, multiply it by its importance, add an adjustment, and you get the model's prediction."

A More Machine-Learning-Looking Equation

You may eventually see something like:

θ := θ − α∇J(θ)

Instead of memorizing it, translate it:

• θ = the model's current settings
• J = how wrong the model is
• ∇J = which direction makes the error increase
• α = how big of a step we take
• − = move in the opposite direction

In normal English:

"Change the model's settings a little bit in the direction that reduces its error."

That is the basic idea behind gradient descent.

The Main Idea

You do not need to memorize every mathematical symbol immediately. When you see an ML equation:

1. Identify what each symbol means.
2. Figure out what operation is happening.
3. Translate the equation into normal English.
4. Only then worry about the formal mathematics.

Once you can translate the symbols, an equation stops looking like:

"θ, α, ∇, Σ ... what is going on?"

and starts sounding like:

"Make a prediction, compare it with the real answer, measure the error, and adjust the model so the next prediction is better."

Python Fundamentals

These are the Python concepts that show up constantly in AI, ML, and DL work — and just as importantly, the ones you should be comfortable explaining during a technical interview.

The goal is not to memorize syntax. The goal is to understand what the code is doing well enough that you can explain it, modify it, debug it, and write a small version of it under pressure.

squares = [x**2 for x in range(5)]
  
  # Same idea written normally:
  squares = []
  
  for x in range(5):
      squares.append(x**2)

config = {
      "lr": 0.001,
      "epochs": 10
  }
  
  print(config["lr"])
  
  config["epochs"] = 20
  
  batch_size = config.get("batch_size", 32)

shape = (32, 3, 224, 224)
  
  batch_size, channels, h, w = shape
  
  print(batch_size)
  # 32

def train(model, epochs=10, lr=0.001):
      print(f"Training for {epochs} epochs")
      print(f"Learning rate: {lr}")

def example(*args, **kwargs):
      print(args)
      print(kwargs)
  
  example(1, 2, lr=0.001, epochs=10)

class Net(nn.Module):
  
      def __init__(self):
          super().__init__()
          self.fc = nn.Linear(10, 1)
  
      def forward(self, x):
          return self.fc(x)

losses = [0.9, 0.6, 0.3]
  
  for epoch, loss in enumerate(losses):
      print(epoch, loss)

predictions = [1, 0, 1]
  labels = [1, 1, 1]
  
  for pred, label in zip(predictions, labels):
      print(pred, label)

numbers = [1, 2, 3, 4]
  
  squares = list(map(lambda x: x**2, numbers))

try:
      value = int(user_input)
  
  except ValueError:
      print("Input must be a number.")

@torch.no_grad()
  def evaluate(model, x):
      return model(x)

def batches(data, batch_size):
  
      for i in range(0, len(data), batch_size):
          yield data[i:i + batch_size]

Python Interview Questions You Should Be Able to Answer

The Standard You Want

You are interview-ready when you can do more than recognize the syntax.

You should be able to look at a short piece of Python code and:

• Explain what it does line by line.
• Predict its output before running it.
• Find a bug or edge case.
• Rewrite it in a cleaner way.
• Explain why you chose one data structure over another.
• Connect the Python concept to how it appears in ML code.

Syntax gets you through the code. Understanding gets you through the interview.

ML Fundamentals

A week-by-week series — starting from the unglamorous but essential work of cleaning data, then building up through classical models, feature engineering, and optimization.

Deep Learning

A 14-week series — starting from the bridge between classical ML and neural networks, then building up through architectures, training techniques, generative models, and reinforcement learning.

SQL

Most real-world data starts in a database. Being able to pull exactly what you need with SQL is often the first step before any ML work even begins.

SELECT name, age
  FROM users
  WHERE age > 25;

SELECT orders.id, users.name
  FROM orders
  LEFT JOIN users
    ON orders.user_id = users.id;

SELECT department, AVG(salary)
  FROM employees
  GROUP BY department;

SELECT name FROM users
  WHERE id IN (
    SELECT user_id FROM orders
    WHERE total > 100
  );

CREATE INDEX idx_user_id
  ON orders (user_id);

SQL Interview Questions You Should Be Able to Answer

The Standard You Want

You should be able to write a query from a plain-English question without hesitating, and explain what happens to your result if the data has duplicates or missing values.

A working query isn't enough — know why it returns exactly what it does.

ROS (Robot Operating System)

ROS is the standard middleware for robotics — it doesn't run robots directly, but provides the communication framework that lets different parts of a robotic system talk to each other.

rosrun my_package my_node.py

pub = rospy.Publisher('velocity', Twist, queue_size=10)
  pub.publish(msg)
  
  rospy.Subscriber('velocity', Twist, callback)

from geometry_msgs.msg import Twist
  
  msg = Twist()
  msg.linear.x = 1.0

<launch>
    <node pkg="my_package" type="my_node.py" name="my_node" />
  </launch>

ROS Interview Questions You Should Be Able to Answer

The Standard You Want

You should be able to sketch out a basic node graph for a simple robot task — what nodes exist, what topics connect them, and what data flows where.

ROS is about communication design as much as it is about robotics.

CUDA

CUDA is what lets PyTorch (and other frameworks) run computations on an NVIDIA GPU instead of the CPU — often 10-100x faster for the matrix math deep learning relies on.

import torch
  
  device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = model.to(device)
  x = x.to(device)
  
  output = model(x)

torch.cuda.memory_allocated()
  torch.cuda.empty_cache()

scaler = torch.cuda.amp.GradScaler()
  
  with torch.cuda.amp.autocast():
      output = model(x)
      loss = loss_fn(output, y)

CUDA Interview Questions You Should Be Able to Answer

The Standard You Want

You should be comfortable debugging a device-mismatch error immediately, and know what to try first when you hit an out-of-memory error mid-training.

A GPU only helps if your code is actually using it correctly.

Simulation Environments

Before deploying to real hardware, robotics and RL models are usually trained and tested in simulation — faster, safer, and far cheaper than breaking real robots.

import mujoco
  
  mujoco.mj_step(model, data)

# Conceptual — thousands of environments
  # stepped together on GPU
  envs = IsaacEnv(num_envs=4096)
  obs = envs.reset()

# Conceptual
  env.randomize_physics(friction_range=(0.5, 1.5))

policy.load("trained_in_sim.pt")
  real_robot.run(policy)

Simulation Interview Questions You Should Be Able to Answer

The Standard You Want

You should understand simulation not just as a testing tool, but as a way to generate cheap, safe training data at a scale real hardware can't match.

Simulation scale is often the difference between an RL policy that works and one that doesn't.