The Environment: PyTorch & Tensors

How this course works (hybrid)

Every module shows you real, copyable code alongside simulated animations that make it click. You can copy any code block and run it yourself — in Google Colab (free, in your browser) or on your own machine.

What you need to train models

Three things, and that's it:

Where should your code run?

You have three options. For starting out, Google Colab is the clear winner — zero install, a free GPU, works on any laptop (even a Chromebook). Here's the honest comparison:

Installing PyTorch — both paths

Path A — Google Colab (recommended, zero install)

Go to colab.research.google.com → New Notebook. PyTorch is already installed. Just verify it — paste this into a cell and press ▶ (Shift+Enter):

import torch
print("PyTorch version:", torch.__version__)
print("GPU available:", torch.cuda.is_available())

To turn on the free GPU in Colab: menu → Runtime → Change runtime type → Hardware accelerator → GPU → Save. Then re-run — GPU available: becomes True.

Path B — Local machine (when you're ready to own it)

First make an isolated environment (so PyTorch doesn't clash with other projects), then install:

# 1. create & activate a virtual environment
python -m venv ai-env
# Windows:
ai-env\Scripts\activate
# Mac/Linux:
source ai-env/bin/activate

# 2. install PyTorch (CPU version — works everywhere)
pip install torch

# 3. verify
python -c "import torch; print(torch.__version__)"

"Is my setup ready?" — the verification walkthrough

This simulates what you'll see when you run the checks. Step through it to know exactly what a healthy setup looks like — then run the real code above yourself.

Tensors — the one thing everything is made of

A tensor is just a container of numbers with a shape. You already met them without the name: in fundamentals, a flattened image was a vector (Module 1), and a word embedding was a vector (Module 4). A tensor generalizes that to any number of dimensions.

The ladder of shapes:

import torch

# 0-D: a scalar (single number)
a = torch.tensor(7.0)                     # shape: ()

# 1-D: a vector (like an embedding)
b = torch.tensor([1.0, 2.0, 3.0])         # shape: (3,)

# 2-D: a matrix (like a batch of vectors, or a grayscale image)
c = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])          # shape: (2, 3)

# 3-D: e.g. a color image (height x width x RGB)
d = torch.randn(4, 4, 3)                 # shape: (4, 4, 3)

print(b.shape)      # torch.Size([3])
print(c.shape)      # torch.Size([2, 3])

Tensor playground — see the shapes

Click each dimension to see the tensor and its shape. The real code that builds it is shown too — copy and try it.

import torch
t = torch.tensor(7.0)   # scalar, shape ()

Tensor operations — the moves you'll use constantly

Knowing what a tensor is isn't enough — you need to manipulate them. These four operations show up in almost every model you'll ever write. They're also where beginners hit their first real wall, so it's worth getting comfortable now.

1. Element-wise math & matrix multiply

Math on tensors happens on every element at once (no loops). And @ is matrix multiply — the single most important operation in neural networks (every layer is basically x @ W).

a = torch.tensor([1., 2., 3.])
b = torch.tensor([10., 20., 30.])

a + b          # tensor([11., 22., 33.])  — element-wise, no loop
a * 2          # tensor([2., 4., 6.])     — scalar applies to all

M = torch.randn(2, 3)
x = torch.randn(3, 4)
M @ x          # shape (2, 4)  — matrix multiply (this is a neural net layer!)

2. Indexing & slicing

Grab parts of a tensor just like Python lists — but across multiple dimensions.

t = torch.tensor([[1,2,3],
                  [4,5,6]])   # shape (2, 3)

t[0]        # tensor([1, 2, 3])  — first row
t[:, 1]     # tensor([2, 5])     — second column (: means "all rows")
t[0, 2]     # tensor(3)          — row 0, col 2

3. Reshaping with .view() / .reshape()

Rearrange the same numbers into a different shape — used constantly to make tensors fit the next layer. The total number of elements must stay the same.

t = torch.arange(6)        # tensor([0,1,2,3,4,5]), shape (6,)

t.view(2, 3)          # [[0,1,2],[3,4,5]]  — same data, shape (2, 3)
t.view(3, 2)          # [[0,1],[2,3],[4,5]] — shape (3, 2)
t.view(-1, 2)         # -1 means "figure it out" → shape (3, 2)

4. Broadcasting

PyTorch auto-stretches smaller tensors to match bigger ones so shapes line up — no manual copying. It feels like magic until it bites you, so know it exists.

M = torch.ones(3, 3)      # shape (3, 3)
row = torch.tensor([1., 2., 3.])  # shape (3,)

M + row        # row is auto-"broadcast" to every row of M
               # [[2,3,4],[2,3,4],[2,3,4]]  — no loop needed

CPU vs GPU — the one-line superpower

A CPU does a few things very fast, one after another. A GPU does thousands of things at once — and training is thousands of identical number-crunches, so it's a perfect fit. The magic is that switching is one line:

# pick GPU if available, else CPU — the standard pattern
device = "cuda" if torch.cuda.is_available() else "cpu"

x = torch.randn(1000, 1000)
x = x.to(device)          # move the tensor to the GPU (or CPU)

print("running on:", device)

Watch the difference on a big matrix multiply (simulated):

Quick challenge

What you set up

Next up → Module 2: Autograd — the engine that makes training possible. You'll build the "turning the knobs" from fundamentals Module 3 as real code: PyTorch computing gradients automatically so a network can learn.