Tensors & PyTorch — Programuoki

Code

Real pictures: fashion.py and the first run

The tests pass — all six of your functions are correct. Now run them on real pictures.

Two files in this step, and both are already complete — they are not your task.

`fashion.py` — loading the data

The whole point of it is one call and one line of arithmetic:

ds = datasets.FashionMNIST(DATA_ROOT, train=(split == "train"), download=True)
x, y = ds.data, ds.targets      # x: [N, 28, 28] uint8
...
return x.reshape(len(x), -1).float() / 255.0, y

download=True — the first time it downloads the set (about 31 MB) into a downloads/ folder, later it finds it there.
x.reshape(len(x), -1) — your flatten_batch, only ready-made: [N, 28, 28] → [N, 784].
.float() / 255.0 — from uint8 0–255 to float32 0–1. You saw the same division in step 2.
n=... — take only the first n images. From lesson 3 on we use n=10_000, so every script runs in seconds.

The function returns (x, y): x is [n, 784] of type float32, y is [n] of type int64 (the class number 0–9). The file also holds CLASSES, the ten names.

What you may need to get this running

ModuleNotFoundError: No module named 'torchvision' — pip install torchvision into the same environment where you installed torch (the same story you met in lesson 1 with torch). fashion.py uses it only to download the data. Pillow, which you need in the homework, comes with it.
Python version. fashion.py uses the int | None notation, so you need Python 3.10 or newer.
The first run prints a long line of percentages (0.1%0.2%...) — that is the download. Silent afterwards.

`tensors_demo.py` — now complete

The right-hand panel now shows the complete version of your file: holes filled, functions written, and at the bottom image_demo() and main(). Compare it with yours — if the tests passed, it should look alike.

Three things were added:

from fashion import CLASSES, load_fashion at the top;
image_demo() — takes one picture and prints its shape and label;
main() — calls everything you wrote and prints what you saw in step 2.

Run it

python tensors_demo.py

You should see (the first time, download percentages come before this):

shape: torch.Size([2, 3]) dtype: torch.float32 device: cpu
a * 2 + 1 = tensor([[ 3.,  5.,  7.],
        [ 9., 11., 13.]])
a + row = tensor([[11., 22., 33.],
        [14., 25., 36.]])
a @ w = tensor([[-1.],
        [-1.]])
loss: 9.0
w.grad: -12.0 b.grad: -6.0
image shape: torch.Size([28, 28]) label: 9 Ankle boot
pixel range: 0.0 to 1.0
flattened for a neuron: torch.Size([784])

Every value matches the tables of step 2 — only now your code produced them. The last three lines are no longer from small numbers but from a real picture: [28, 28], label 9 (Ankle boot), [784].

Run the tests too — there are 11 now, since two about load_fashion were added:

$ python -m unittest
...........
----------------------------------------------------------------------
Ran 11 tests in 0.074s

OK

(The first time they take longer — the download.)

fashion.py CREATE

Create this file in ./

"""fashion.py — load FashionMNIST as plain tensors."""

import os

import torch
from torchvision import datasets

# Where torchvision caches the download. Override with the NN_DATA env variable.
DATA_ROOT = os.environ.get("NN_DATA", "downloads")

CLASSES = [
    "T-shirt",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]


def load_fashion(
    split: str = "train", n: int | None = None
) -> tuple[torch.Tensor, torch.Tensor]:
    """Return (x, y). x is [n, 784] float32 in 0..1, y is [n] int64 labels."""
    ds = datasets.FashionMNIST(DATA_ROOT, train=(split == "train"), download=True)
    x, y = ds.data, ds.targets  # x: [N, 28, 28] uint8
    if n is not None:
        x, y = x[:n], y[:n]
    return x.reshape(len(x), -1).float() / 255.0, y

tensors_demo.py MODIFY 43 lines changed

Edit this file in ./

"""tensors_demo.py — tensors, vectorized ops, autograd, and an image as a tensor."""

import torch

from fashion import CLASSES, load_fashion


def loss_and_grads(w0: float, x: float, b0: float, target: float):
    """Squared error of the line  y = w * x + b  against a target, plus gradients.

    Returns (loss, w.grad, b.grad): the loss as a plain float and the two
    gradients as the 0-dimensional tensors PyTorch fills in.
    """
    w = torch.tensor(w0, requires_grad=True)
    b = torch.tensor(b0, requires_grad=True)

    loss = (w * x + b - target) ** 2

    # HOLE 1: ask PyTorch for the gradients of `loss` with respect to w and b.
    # Without it, w.grad and b.grad stay None.
    loss.backward()

    return loss.item(), w.grad, b.grad


def flatten_image(image: torch.Tensor) -> torch.Tensor:
    """Turn one [28, 28] image into the [784] vector a neuron takes as input.

    The pixels keep their row-by-row order.
    """
    # HOLE 2: reshape the image into ONE dimension of length 784.
    return image.reshape(-1)


def affine(a: torch.Tensor, scale: float, shift: float) -> torch.Tensor:
    """Return a * scale + shift, for every element at once.

    No Python loop, and `a` itself must not be changed: build a new tensor.
    """
    return a * scale + shift


def add_row(a: torch.Tensor, row: torch.Tensor) -> torch.Tensor:
    """Add a [3] row to every row of a [2, 3] tensor and return the [2, 3] sum.

    No loop, no copying the row two times by hand: let broadcasting stretch it.
    """
    return a + row


def weighted_sum(x: torch.Tensor, w: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
    """Matrix product of x and w, plus b added to every row.

    x is [n, k], w is [k, m], b is [m]; the result is [n, m].
    """
    return x @ w + b


def flatten_batch(images: torch.Tensor) -> torch.Tensor:
    """Turn a batch of images [n, 28, 28] into [n, 784]: one row per image.

    Row i must equal flatten_image(images[i]). Do not hard-code n.
    """
    return images.reshape(len(images), -1)


def image_demo() -> None:
    x, y = load_fashion("train", n=1)
    image = x[0].reshape(28, 28)
    print("image shape:", image.shape, "label:", y[0].item(), CLASSES[y[0]])
    print("pixel range:", image.min().item(), "to", image.max().item())
    print("flattened for a neuron:", flatten_image(image).shape)


def main() -> None:
    a = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
    print("shape:", a.shape, "dtype:", a.dtype, "device:", a.device)

    # Vectorized: one expression, no Python loop.
    print("a * 2 + 1 =", affine(a, 2.0, 1.0))

    # Broadcasting: a [3] row is stretched across both rows of a [2, 3].
    row = torch.tensor([10.0, 20.0, 30.0])
    print("a + row =", add_row(a, row))

    # Matrix product: [2, 3] @ [3, 1] -> [2, 1]
    w = torch.tensor([[0.5], [0.0], [-0.5]])
    print("a @ w =", weighted_sum(a, w, torch.zeros(1)))

    # Autograd: loss = (w * x + b - 10) ** 2 at w=3, x=2, b=1
    loss, dw, db = loss_and_grads(3.0, 2.0, 1.0, 10.0)
    print("loss:", loss)
    print("w.grad:", dw.item(), "b.grad:", db.item())

    image_demo()


if __name__ == "__main__":
    main()

test_tensors_demo.py MODIFY 17 lines changed