labels = np.array([0, 2, 2, 1, 2])
np.bincount(labels)               # array([1, 1, 3]): one 0, one 1, three 2s
np.bincount(labels, minlength=5)  # array([1, 1, 3, 0, 0])

import os
import shutil
import subprocess
from pathlib import Path

REPO_URL = 'https://github.com/wtheisen/nd-cse-30124-homeworks.git'

try:
    import google.colab
except ImportError:
    # Reuse a local checkout, including when launched from a homework subfolder.
    DATA_ROOT = next((p for p in [Path.cwd(), *Path.cwd().parents]
                      if (p / '.git').exists() and (p / 'evidence').is_dir()), None)
    if DATA_ROOT is None:
        DATA_ROOT = Path.cwd() / 'nd-cse-30124-homeworks'
else:
    # Leave the old checkout before deleting it, including on a setup-cell rerun.
    os.chdir('/content')
    DATA_ROOT = Path('/content/nd-cse-30124-homeworks')
    # Fetch fresh evidence every time this cell runs in Colab.
    if DATA_ROOT.exists():
        shutil.rmtree(DATA_ROOT)

if not DATA_ROOT.exists():
    subprocess.run(['git', 'clone', REPO_URL, str(DATA_ROOT)], check=True)

if not (DATA_ROOT / '.git').exists():
    raise RuntimeError(f'{DATA_ROOT} exists but is not a Git checkout. Choose a different clone location.')

# All later relative paths now start at the homework repository root.
os.chdir(DATA_ROOT)
DATA_ROOT = Path.cwd()

import json
import math
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import TensorDataset, DataLoader

torch.manual_seed(42)

EVIDENCE_DIR = DATA_ROOT / 'evidence' / 'homework06'
required = ['emnist_balanced_small/emnist_balanced_small_train.npz', 'emnist_balanced_small/classes.json']
if any(not (EVIDENCE_DIR / name).is_file() for name in required):
    raise FileNotFoundError('HW06 evidence is missing. Rerun the setup cell with an internet connection, or check that your local repository contains the evidence/homework06 files.')
os.chdir(EVIDENCE_DIR)

raw = np.load('emnist_balanced_small/emnist_balanced_small_train.npz')
X_raw, y_raw = raw['X'], raw['y']
classes = json.loads(Path('emnist_balanced_small/classes.json').read_text())['classes']

# TODO: Count the examples in each class, including classes with zero examples.
counts = None

print('Images:', X_raw.shape, X_raw.dtype, '| pixel range:', X_raw.min(), 'to', X_raw.max())
print('Labels:', y_raw.shape, y_raw.dtype)
print('Classes:', len(classes), '->', ' '.join(classes))
print('Examples per class: min', counts.min(), '| max', counts.max())
print('First 8 labels:', y_raw[:8], '| labels 198-205:', y_raw[198:206])

# Supplied helper: draw a grid of labeled characters.
def show_characters(images, titles, columns=12, suptitle=None):
    rows = math.ceil(len(images) / columns)
    title_lines = max(str(title).count('\n') + 1 for title in titles)
    fig, axes = plt.subplots(rows, columns, figsize=(columns * 1.1, rows * (1.1 + 0.3 * title_lines)), squeeze=False)
    for ax in axes.flat:
        ax.axis('off')
    for ax, image, title in zip(axes.flat, images, titles):
        ax.imshow(image, cmap='gray', vmin=0, vmax=255 if image.max() > 1 else 1)
        ax.set_title(title, fontsize=9)
    if suptitle:
        fig.suptitle(suptitle)
    fig.tight_layout()
    plt.show()

# Supplied: one example of every class, in class-ID order.
first_of_each = [np.flatnonzero(y_raw == label)[0] for label in range(len(classes))]
show_characters(X_raw[first_of_each], [f'{classes[label]} ({label})' for label in range(len(classes))],
                suptitle='One archive example per class: character (class ID)')

Images: (9400, 28, 28) uint8 | pixel range: 0 to 255
Labels: (9400,) int64
Classes: 47 -> 0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b d e f g h n q r t
Examples per class: min 200 | max 200
First 8 labels: [45 45 45 45 45 45 45 45] | labels 198-205: [45 45 36 36 36 36 36 36]

pixels = np.array([[200, 100], [0, 255]], dtype=np.uint8)
pixels + pixels               # [[144, 200], [0, 254]]   <- 200 + 200 wrapped around!
t = torch.from_numpy(pixels.copy()).float() / 255.0
# tensor([[0.7843, 0.3922],
#         [0.0000, 1.0000]])
t.unsqueeze(0).shape          # torch.Size([1, 2, 2]): a new dimension of size 1 at position 0

def to_image_tensor(X):
    # TODO: Convert to float, normalize to [0, 1] exactly once, and add a channel dimension.
    return None

# TODO: Keep the labels as integer class IDs.
labels = None
images = to_image_tensor(X_raw)

print('Images:', tuple(images.shape), images.dtype)
print('Pixel range:', float(images.min()), 'to', float(images.max()))
print('Labels:', tuple(labels.shape), labels.dtype)

Images: (9400, 1, 28, 28) torch.float32
Pixel range: 0.0 to 1.0
Labels: (9400,) torch.int64

batch = torch.arange(8.).reshape(2, 1, 2, 2)   # two tiny 2x2 "images"
batch.flatten().shape     # torch.Size([8])    <- both images merged into one vector!
batch.flatten(1).shape    # torch.Size([2, 4]) <- one row of 4 pixels per image
batch.flatten(1)
# tensor([[0., 1., 2., 3.],
#         [4., 5., 6., 7.]])

# Supplied: keep the same split across HW06 and HW07. Test data are opened only in HW07.
order = torch.randperm(len(images), generator=torch.Generator().manual_seed(42))
val_idx, train_idx = order[:940], order[940:]
train_data = TensorDataset(images[train_idx], labels[train_idx])
val_data = TensorDataset(images[val_idx], labels[val_idx])

def make_loader(data, shuffle=False, seed=42, batch_size=128):
    return DataLoader(data, batch_size=batch_size, shuffle=shuffle,
                      generator=torch.Generator().manual_seed(seed), num_workers=0)

# TODO: Build a shuffled training loader and an unshuffled validation loader.
train_loader = None
val_loader = None

xb, yb = next(iter(val_loader))

# TODO: Flatten every dimension except the batch dimension.
flat_batch = None

print('Train / validation:', len(train_data), '/', len(val_data))
print('Batches per pass: train', len(train_loader), '| validation', len(val_loader))
print('Last validation batch size:', len(val_data) % 128)
print('Image batch:', tuple(xb.shape), '| label batch:', tuple(yb.shape))
print('Flattened batch:', tuple(flat_batch.shape))
print('Row 0 is still image 0:', torch.equal(flat_batch[0], xb[0].reshape(-1)))

Train / validation: 8460 / 940
Batches per pass: train 67 | validation 8
Last validation batch size: 44
Image batch: (128, 1, 28, 28) | label batch: (128,)
Flattened batch: (128, 784)
Row 0 is still image 0: True

A = torch.tensor([[1., 2.], [3., 4.]])   # (2, 2)
B = torch.tensor([[1., 0.], [0., 1.], [1., 1.]])   # (3, 2)
A @ B.T                                  # (2, 3): row i of A dotted with row j of B
A @ B.T + torch.tensor([10., 20., 30.])  # the bias is added to every row

class LinearLayer:
    def __init__(self, input_dim, output_dim, device='cpu'):
        self.W = torch.randn(output_dim, input_dim, device=device) * math.sqrt(2 / input_dim)
        self.b = torch.zeros(output_dim, device=device)

    def forward(self, X):
        # TODO: Cache the input for HW07, then apply the affine transformation.
        self.X = None
        return None

layer = LinearLayer(2, 3)
layer.W = torch.tensor([[1., 2.], [-1., 1.], [0., 3.]])
layer.b = torch.tensor([0., 1., -1.])
X_toy = torch.tensor([[1., 2.], [3., 4.]])

print(layer.forward(X_toy))
print('Output shape:', tuple(layer.forward(X_toy).shape))

first_layer = LinearLayer(784, 256)
print('First real layer:', tuple(flat_batch.shape), '->', tuple(first_layer.forward(flat_batch).shape))

tensor([[ 5.,  2.,  5.],
        [11.,  2., 11.]])
Output shape: (2, 3)
First real layer: (128, 784) -> (128, 256)

def he_std(D):
    # TODO: Return the weight standard deviation LinearLayer uses for an input width D.
    return None

# Supplied: the weight standard deviation for each of the three starting rules.
def weight_std(rule, D):
    if rule == 'too small (0.01)':
        return 0.01
    if rule == 'too large (1.0)':
        return 1.0
    return he_std(D)

def activation_scales(X, rule, widths=(256, 256, 256), seed=0):
    generator = torch.Generator().manual_seed(seed)
    stds, H = [], X
    for width in widths:
        W = torch.randn(width, H.shape[1], generator=generator) * weight_std(rule, H.shape[1])
        H = (H @ W.T).clamp_min(0)
        stds.append(round(float(H.std()), 3))
    return stds

for rule in ['too small (0.01)', 'He: sqrt(2 / D)', 'too large (1.0)']:
    print(f'{rule:>17}: activation std after layers 1, 2, 3 = {activation_scales(flat_batch, rule)}')

zero_layer = LinearLayer(784, 4)
zero_layer.W = torch.zeros(4, 784)
print('Zero-initialized units produce identical outputs:',
      bool((zero_layer.forward(flat_batch) == zero_layer.forward(flat_batch)[:, :1]).all()))

 too small (0.01): activation std after layers 1, 2, 3 = [0.061, 0.006, 0.001]
  He: sqrt(2 / D): activation std after layers 1, 2, 3 = [0.308, 0.277, 0.25]
  too large (1.0): activation std after layers 1, 2, 3 = [6.09, 61.951, 633.286]
Zero-initialized units produce identical outputs: True

z = torch.tensor([[-2.0, 0.0, 3.0],
                  [ 1.5, -0.1, -7.0]])
z.clamp_min(0)
# tensor([[0.0, 0.0, 3.0],
#         [1.5, 0.0, 0.0]])

class ReLU:
    def forward(self, X):
        # TODO: Cache the input for HW07, then keep only its positive values.
        self.X = None
        return None

print(ReLU().forward(torch.tensor([[-2.0, 0.0, 3.0], [1.5, -0.1, -7.0]])))

# Supplied: two stacked linear layers versus one merged layer.
torch.manual_seed(0)
first, second = LinearLayer(4, 5), LinearLayer(5, 3)
first.b, second.b = torch.randn(5), torch.randn(3)
merged = LinearLayer(4, 3)
merged.W = second.W @ first.W
merged.b = first.b @ second.W.T + second.b
X_small = torch.randn(6, 4)

stacked = second.forward(first.forward(X_small))
with_relu = second.forward(ReLU().forward(first.forward(X_small)))
print('Two linear layers equal one merged layer:', torch.allclose(stacked, merged.forward(X_small), atol=1e-5))
print('With ReLU in between, still equal:      ', torch.allclose(with_relu, merged.forward(X_small), atol=1e-5))

tensor([[0.0000, 0.0000, 3.0000],
        [1.5000, 0.0000, 0.0000]])
Two linear layers equal one merged layer: True
With ReLU in between, still equal:       False

torch.exp(torch.tensor([1000., 1001., 999.]))   # tensor([inf, inf, inf])
# inf / inf = nan, and one nan contaminates every later calculation.

def log_softmax(logits):
    # TODO: Subtract each row's maximum logit.
    shifted = None
    # TODO: Subtract each row's log-sum-exp from the shifted logits.
    return None

small = torch.tensor([[2., 1., 0.]])
huge = torch.tensor([[1000., 1001., 999.]])
print('Naive softmax of huge logits:', torch.exp(huge) / torch.exp(huge).sum())
print('Log probabilities of [2, 1, 0]:', log_softmax(small).numpy().round(3))
print('Probabilities of [2, 1, 0]:', log_softmax(small).exp().numpy().round(3))
print('Probabilities of [1000, 1001, 999]:', log_softmax(huge).exp().numpy().round(3))

random_logits = torch.randn(5, 47) * 30
print('Each row sums to one:', torch.allclose(log_softmax(random_logits).exp().sum(dim=1), torch.ones(5)))
print('Matches F.log_softmax:', torch.allclose(log_softmax(random_logits), F.log_softmax(random_logits, dim=1), atol=1e-5))

two_class = log_softmax(torch.tensor([[1.5, 0.]])).exp()[0, 0]
print(f'Two-class softmax {float(two_class):.4f} vs sigmoid {float(torch.sigmoid(torch.tensor(1.5))):.4f}')

Naive softmax of huge logits: tensor([[nan, nan, nan]])
Log probabilities of [2, 1, 0]: [[-0.408 -1.408 -2.408]]
Probabilities of [2, 1, 0]: [[0.665 0.245 0.09 ]]
Probabilities of [1000, 1001, 999]: [[0.245 0.665 0.09 ]]
Each row sums to one: True
Matches F.log_softmax: True
Two-class softmax 0.8176 vs sigmoid 0.8176

log_p = torch.tensor([[-0.4, -1.4, -2.4],
                      [-0.4, -1.4, -2.4]])
targets = torch.tensor([0, 2])
log_p[torch.arange(2), targets]   # tensor([-0.4, -2.4]): entries [0, 0] and [1, 2]

def cross_entropy(logits, targets):
    # TODO: Select each example's correct-class log probability and average the negatives.
    log_p = None
    return None

pair = torch.tensor([[2., 1., 0.], [2., 1., 0.]])
pair_targets = torch.tensor([0, 2])
print(f'Worked example loss: ours {float(cross_entropy(pair, pair_targets)):.4f} | '
      f'PyTorch {float(F.cross_entropy(pair, pair_targets)):.4f}')

huge_pair = torch.tensor([[1000., 1001., 999.], [-1000., -1001., -999.]])
huge_targets = torch.tensor([1, 2])
print(f'Huge logits loss:    ours {float(cross_entropy(huge_pair, huge_targets)):.4f} | '
      f'PyTorch {float(F.cross_entropy(huge_pair, huge_targets)):.4f}')

probabilities = F.softmax(pair, dim=1)
print(f'Common bug, softmax passed to F.cross_entropy: {float(F.cross_entropy(probabilities, pair_targets)):.4f}')

uniform = torch.zeros(4, 47)   # every class gets the same logit
print(f'Loss when all 47 classes are equally likely: {float(cross_entropy(uniform, torch.tensor([0, 5, 20, 46]))):.4f}')

Worked example loss: ours 1.4076 | PyTorch 1.4076
Huge logits loss:    ours 0.4076 | PyTorch 0.4076
Common bug, softmax passed to F.cross_entropy: 1.0848
Loss when all 47 classes are equally likely: 3.8501

toy_layers = [LinearLayer(2, 3), ReLU(), LinearLayer(3, 1)]
H = torch.ones(5, 2)            # 5 examples, 2 features each
for layer in toy_layers:
    H = layer.forward(H)        # each layer's output becomes the next layer's input
print(H.shape)                  # torch.Size([5, 1])

class ScratchFFN:
    def __init__(self, device='cpu'):
        self.layers = [LinearLayer(784, 256, device), ReLU(),
                       LinearLayer(256, 128, device), ReLU(),
                       LinearLayer(128, 47, device)]

    def forward(self, X):
        # TODO: Flatten each image, then apply every layer in order.
        return None

torch.manual_seed(42)
model = ScratchFFN()
xb4, yb4 = next(iter(make_loader(val_data, batch_size=4)))

activations = xb4.flatten(1)
shapes = [tuple(activations.shape)]
for layer in model.layers:
    activations = layer.forward(activations)
    shapes.append((type(layer).__name__, tuple(activations.shape)))
print('Input:', shapes[0])
for name, shape in shapes[1:]:
    print(f'  after {name:<11} {shape}')

parameter_count = sum(layer.W.numel() + layer.b.numel() for layer in model.layers if hasattr(layer, 'W'))
print('Trainable parameters:', parameter_count)
print('forward() output shape:', tuple(model.forward(xb4).shape))
print(f'Untrained loss on the first validation batch: {float(cross_entropy(model.forward(xb), yb)):.4f}')

Input: (4, 784)
  after LinearLayer (4, 256)
  after ReLU        (4, 256)
  after LinearLayer (4, 128)
  after ReLU        (4, 128)
  after LinearLayer (4, 47)
Trainable parameters: 239919
forward() output shape: (4, 47)
Untrained loss on the first validation batch: 3.9775

net = nn.Sequential(nn.Linear(3, 2), nn.ReLU())
net[0].weight.shape                 # torch.Size([2, 3])
with torch.no_grad():
    net[0].weight.copy_(torch.ones(2, 3))   # overwrite in place

class TorchFFN(nn.Module):
    def __init__(self):
        super().__init__()
        # TODO: Match the scratch architecture exactly.
        self.layers = None

    def forward(self, X):
        return self.layers(X)

def copy_to_torch(scratch, reference):
    scratch_linear = [layer for layer in scratch.layers if isinstance(layer, LinearLayer)]
    torch_linear = [layer for layer in reference.layers if isinstance(layer, nn.Linear)]
    with torch.no_grad():
        for ours, theirs in zip(scratch_linear, torch_linear):
            # TODO: Copy this layer's weights and bias into the PyTorch layer.
            pass

reference = TorchFFN()
print(reference)

with torch.no_grad():
    before = (model.forward(xb) - reference(xb)).abs().max()
    copy_to_torch(model, reference)
    after = (model.forward(xb) - reference(xb)).abs().max()
print(f'Largest logit difference before copying weights: {float(before):.2f}')
print('Largest logit difference after copying is below 1e-5:', bool(after < 1e-5))

TorchFFN(
  (layers): Sequential(
    (0): Flatten(start_dim=1, end_dim=-1)
    (1): Linear(in_features=784, out_features=256, bias=True)
    (2): ReLU()
    (3): Linear(in_features=256, out_features=128, bias=True)
    (4): ReLU()
    (5): Linear(in_features=128, out_features=47, bias=True)
  )
)
Largest logit difference before copying weights: 2.04
Largest logit difference after copying is below 1e-5: True

logits = torch.tensor([[0.1, 2.0], [3.0, -1.0], [0.0, 0.5]])
targets = torch.tensor([1, 1, 1])
logits.argmax(dim=1)                                  # tensor([1, 0, 1])
int((logits.argmax(dim=1) == targets).sum())          # 2 correct
float(F.cross_entropy(logits, targets, reduction='sum'))   # total, not mean

@torch.no_grad()
def evaluate(model, loader):
    total_loss, correct, count = 0., 0, 0
    for xb_eval, yb_eval in loader:
        logits = model(xb_eval) if isinstance(model, nn.Module) else model.forward(xb_eval)
        # TODO: Accumulate the summed loss, number correct, and number of examples.
        total_loss += 0
        correct += 0
        count += 0
    return {'loss': round(total_loss / count, 4), 'accuracy': round(correct / count, 4)}

print('Untrained scratch FFN, validation:', evaluate(model, val_loader))
print('Untrained PyTorch FFN, validation:', evaluate(reference, val_loader))
print(f'Uniform guessing: loss {math.log(47):.4f}, accuracy {1 / 47:.4f}')

with torch.no_grad():
    probabilities = log_softmax(model.forward(xb)).exp()
    confidence, predicted = probabilities.max(dim=1)
print(f'Average confidence in its own prediction: {float(confidence.mean()):.3f}')
print('Distinct classes predicted for 128 images:', len(predicted.unique()))

# Supplied: show the first 12 validation images with the untrained model's guesses.
show_characters(xb[:12, 0].numpy(),
                [f'true {classes[int(t)]}\nguess {classes[int(p)]} ({float(c):.2f})'
                 for t, p, c in zip(yb[:12], predicted[:12], confidence[:12])],
                columns=6, suptitle='The untrained network\'s guesses (and confidence)')

Untrained scratch FFN, validation: {'loss': 3.9704, 'accuracy': 0.0234}
Untrained PyTorch FFN, validation: {'loss': 3.9704, 'accuracy': 0.0234}
Uniform guessing: loss 3.8501, accuracy 0.0213
Average confidence in its own prediction: 0.056
Distinct classes predicted for 128 images: 17

GENERATE = False
NOTEBOOK_PATH = DATA_ROOT / 'homeworks' / 'homework06' / 'homework06.ipynb'

if GENERATE:
    import json
    import nbformat
    from nbconvert import HTMLExporter
    from pathlib import Path

    try:
        from google.colab import _message, files
    except ImportError:
        current = nbformat.read(NOTEBOOK_PATH, as_version=4)
        html_path = NOTEBOOK_PATH.with_name('homework06.html')
        in_colab = False
    else:
        captured = _message.blocking_request('get_ipynb', timeout_sec=10)
        current = nbformat.reads(json.dumps(captured['ipynb']), as_version=4)
        html_path = Path('/content/homework06.html')
        in_colab = True

    exporter = HTMLExporter()
    exporter.embed_images = True
    report_html, _ = exporter.from_notebook_node(current)
    html_path.write_text(report_html, encoding='utf-8')
    print(f'Exported {html_path.name}. Open it in a browser before submitting.')

    if in_colab:
        files.download(str(html_path))
    else:
        print(f'Saved to: {html_path}')
else:
    print('Export disabled. Set GENERATE = True when ready.')

Export disabled. Set GENERATE = True when ready.

Task	Description	Points
00	Load the character evidence	0.25
01	Turn images into tensors and batches	0.75
02	Build an affine layer; explain the initialization	0.875
03	Add a nonlinearity; explain the collapse	0.375
04	Turn logits into a stable loss; interpret the chance loss	1.125
05	Assemble the network	0.50
06	Check against PyTorch and inspect the predictions	0.75
07	Report the results to Caulfield	0.375
08	Export the notebook	0
	Total	5.00

File	Contents	When to use it
`emnist_balanced_small_train.npz`	`X`: `(9400, 28, 28)` images, `y`: `(9400,)` labels	Now: we split it into training and validation sets
`emnist_balanced_small_test.npz`	2,350 held-out images and labels	Keep closed until HW07's final comparison
`classes.json`	The ordered list of 47 class names	Translating IDs into characters

Symbol	Meaning	Shape
$X$	A batch of inputs, one example per row	`(B, D)`
$W$	One row of weights per output unit	`(H, D)`
$b$	One bias per output unit	`(H,)`
$Y$	One row of outputs per example	`(B, H)`

	Class 0	Class 1	Class 2	Total
$z_j$	2	1	0
$e^{z_j}$	7.389	2.718	1.000	11.107
$p_j$	0.665	0.245	0.090	1.000

Layer	Weights	Biases	Parameters
Linear 784 → 256	784 × 256 = 200,704	256	200,960
Linear 256 → 128	256 × 128 = 32,768	128	32,896
Linear 128 → 47	128 × 47 = 6,016	47	6,063
Total			239,919

Our scratch version	PyTorch version	Notes
`X.flatten(1)`	`nn.Flatten()`	Flattens from dimension 1 by default, keeping the batch
`LinearLayer(D, H)`	`nn.Linear(D, H)`	`.weight` has shape `(H, D)` and `.bias` shape `(H,)`, exactly like our `W` and `b`
`ReLU()`	`nn.ReLU()`
list of layers + loop	`nn.Sequential(...)`	Calls each module in order
`cross_entropy`	`F.cross_entropy`	Takes raw logits

Introduction to Artificial Intelligence - Homework Assignment 06 (5 pts.)¶

Story Progression¶

Task 00: Load the Character Evidence¶

Task 00-1: Description (0 pts.)¶

What Is in the Archive?¶

Your Task¶

Python Help¶

Useful Links¶

Task 00-1: Code (0.25 pts.)¶

Task 00-1: Expected Output (0 pts.)¶

Task 01: Turn Images into Tensors and Batches¶

Task 01-1: Description (0 pts.)¶

From NumPy Arrays to Tensors¶

Worked Example¶

Your Task¶

Python Help¶

Useful Links¶

Task 01-1: Code (0.25 pts.)¶

Task 01-1: Expected Output (0 pts.)¶

Task 01-2: Description (0 pts.)¶

Splitting, Batching, and Flattening¶

Worked Example¶

Your Task¶

Python Help¶

Useful Links¶

Task 01-2: Code (0.5 pts.)¶

Task 01-2: Expected Output (0 pts.)¶

Task 02: Build an Affine Layer¶

Task 02-1: Description (0 pts.)¶

The Same Score, 256 Times at Once¶

Worked Example¶

Why Store the Input?¶

Your Task¶

Python Help¶

Useful Links¶

Task 02-1: Code (0.5 pts.)¶

Task 02-1: Expected Output (0 pts.)¶

Task 02-2: Description (0 pts.)¶

Where Should the Weights Start?¶

Worked Example: How Big Does a Sum Get?¶

Your Task¶

Useful Links¶

Task 02-2: Code (0.25 pts.)¶

Task 02-2: Reference Output (0 pts.)¶

Task 02-3: Written Response (0.125 pts.)¶

Task 03: Add a Nonlinearity¶

Task 03-1: Description (0 pts.)¶

Why Can't We Just Stack Linear Layers?¶

ReLU¶

Worked Example¶

Your Task¶

Python Help¶

Task 03-1: Code (0.25 pts.)¶

Task 03-1: Expected Output (0 pts.)¶

Task 03-2: Written Response (0.125 pts.)¶

Story Progression¶

Task 04: Turn Logits into a Stable Loss¶

Task 04-1: Description (0 pts.)¶

From Scores to Probabilities¶

Worked Example¶

The Overflow Problem¶

Working in Log Space¶

Your Task¶

Python Help¶

Useful Links¶

Task 04-1: Code (0.5 pts.)¶

Task 04-1: Expected Output (0 pts.)¶

Task 04-2: Description (0 pts.)¶

How Wrong Was That Prediction?¶

Worked Example¶

Selecting One Entry per Row¶

A Word on PyTorch's Version¶

Your Task¶

Useful Links¶

Task 04-2: Code (0.5 pts.)¶

Task 04-2: Expected Output (0 pts.)¶

Task 04-3: Written Response (0.125 pts.)¶

Task 05: Assemble the Network¶

Task 05-1: Description (0 pts.)¶

Putting the Pieces in Order¶