AIYatra

This is an in-person event only and filling this google form is mandatory https://forms.gle/5oY75Nk7FXzAJCdw5 if not filled, security will not allow at the entrance. Make sure you are filling correct details, as these will be verified against your government id.

The goal is simple:

> By the end of the session, participants should understand PyTorch — not just memorize its APIs.

We will go deep into:

🔹 What exactly is PyTorch?
Python vs PyTorch, PyTorch vs NumPy, eager execution, tensors, neural-network abstractions, and CPU/GPU execution.

🔹 Tensors beyond `torch.tensor()`
Shapes, dimensions, dtypes, devices, indexing, slicing, masking, broadcasting, reductions, matrix multiplication, batched operations, and `einsum`.

🔹 Tensor memory — the part most tutorials skip
Storage, strides, contiguous vs non-contiguous tensors, views vs copies, `reshape`, `view`, `transpose`, `permute`, `squeeze`, and `unsqueeze`.

🔹 Autograd without the magic
We will calculate derivatives manually first and then verify them using PyTorch.
From:
`y = x²`
to:
`z = Wx + b`
to:
`L = (z - y)²`
We will trace exactly how PyTorch builds the computation graph and how gradients eventually arrive in:
`weight.grad`
We will cover `requires_grad`, leaf/non-leaf tensors, `grad_fn`, gradient accumulation, `.backward()`, `torch.autograd.grad`, `detach`, `no_grad`, `inference_mode`, and common in-place operation pitfalls.

🔹 From Tensor → Parameter → Module → Model
We will open up `nn.Module` and understand parameter registration, buffers, submodules, initialization, `state_dict`, train/eval mode, saving and loading.
And then we will build our own `nn.Linear` from scratch instead of treating it as a black box.

🔹 The training loop — completely exposed
No high-level abstractions hiding what happens:
Data → Model → Prediction → Loss → Backward → Gradient → Optimizer → Updated Weights
We will even manually perform:
`W = W - learning_rate × W.grad`
before using `optimizer.step()`.

### Hands-on projects

Project 1: Rebuild `nn.Linear` ourselves and compare its forward pass and gradients against PyTorch's implementation.

Project 2: Build and train a neural network using only tensors, Parameters, matrix multiplication, ReLU, logits, Softmax and Autograd — without relying on high-level layers.

The session succeeds if everyone can confidently answer three questions:
1. Where exactly is a model's weight stored?
2. Where exactly does the gradient come from?
3. What mathematically happens when `optimizer.step()` executes?

Because once these three things are clear, PyTorch stops looking like magic.
Forward computes values.
Backward computes gradients.
Optimizer step changes parameters.

That is where we begin.