Correct ambiguous marks

Author: louishhy

18_Autoencoders/index.ipynb

@@ -119,7 +119,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "9638499c",
    "metadata": {},
    "outputs": [
@@ -151,21 +151,21 @@
     "    \"\"\"Convolutional Denoising Autoencoder\"\"\"\n",
     "    def __init__(self):\n",
     "        super().__init__()\n",
-    "        # Encoder: 28×28 → 14×14 → 7×7\n",
+    "        # Encoder: 28x28 → 14x14 → 7x7\n",
     "        self.encoder = nn.Sequential(\n",
-    "            nn.Conv2d(1, 16, 3, stride=2, padding=1),  # → 14×14×16\n",
+    "            nn.Conv2d(1, 16, 3, stride=2, padding=1),  # → 14x14x16\n",
     "            nn.ReLU(),\n",
-    "            nn.Conv2d(16, 32, 3, stride=2, padding=1), # → 7×7×32\n",
+    "            nn.Conv2d(16, 32, 3, stride=2, padding=1), # → 7x7x32\n",
     "            nn.ReLU(),\n",
     "        )\n",
-    "        # Decoder: 7×7 → 14×14 → 28×28\n",
+    "        # Decoder: 7x7 → 14x14 → 28x28\n",
     "        self.decoder = nn.Sequential(\n",
-    "            nn.ConvTranspose2d(32, 16, 4, stride=2, padding=1), # → 14×14×16\n",
+    "            nn.ConvTranspose2d(32, 16, 4, stride=2, padding=1), # → 14x14x16\n",
     "            nn.ReLU(),\n",
-    "            nn.ConvTranspose2d(16, 1, 4, stride=2, padding=1),  # → 28×28×1\n",
+    "            nn.ConvTranspose2d(16, 1, 4, stride=2, padding=1),  # → 28x28x1\n",
     "            nn.Sigmoid()  # Output in [0, 1]\n",
     "        )\n",
-    "    \n",
+    "\n",
     "    def forward(self, x):\n",
     "        z = self.encoder(x)\n",
     "        x_recon = self.decoder(z)\n",
@@ -250,7 +250,7 @@
     "    x_clean = x_clean.to(device)\n",
     "    x_noisy = add_noise(x_clean, sigma)\n",
     "    x_recon = model(x_noisy)\n",
-    "    \n",
+    "\n",
     "    n = 8\n",
     "    fig, axes = plt.subplots(3, n, figsize=(1.5*n, 4.5))\n",
     "    for i in range(n):\n",
@@ -260,7 +260,7 @@
     "        axes[1, i].axis('off')\n",
     "        axes[2, i].imshow(x_recon[i, 0].cpu(), cmap='gray')\n",
     "        axes[2, i].axis('off')\n",
-    "    \n",
+    "\n",
     "    axes[0, 0].set_ylabel('Clean', fontsize=12)\n",
     "    axes[1, 0].set_ylabel('Noisy', fontsize=12)\n",
     "    axes[2, 0].set_ylabel('Reconstructed', fontsize=12)\n",
@@ -353,21 +353,21 @@
     "    except StopIteration:\n",
     "        train_iter = iter(train_loader)\n",
     "        x_clean, _ = next(train_iter)\n",
-    "    \n",
+    "\n",
     "    x_clean = x_clean.to(device)\n",
     "    x_noisy = add_noise(x_clean, sigma=noise_sigma)\n",
-    "    \n",
+    "\n",
     "    # Forward pass\n",
     "    x_recon = dae(x_noisy)\n",
     "    loss = F.mse_loss(x_recon, x_clean)\n",
-    "    \n",
+    "\n",
     "    # Backward pass\n",
     "    optimizer_dae.zero_grad()\n",
     "    loss.backward()\n",
     "    optimizer_dae.step()\n",
-    "    \n",
+    "\n",
     "    losses.append(loss.item())\n",
-    "    \n",
+    "\n",
     "    if step % 200 == 0:\n",
     "        print(f\"Step {step}/{num_steps} | Loss: {loss.item():.4f}\")\n",
     "\n",
@@ -554,36 +554,36 @@
     "    def __init__(self, latent_dim=8):\n",
     "        super().__init__()\n",
     "        self.latent_dim = latent_dim\n",
-    "        \n",
+    "\n",
     "        # Encoder\n",
     "        self.fc1 = nn.Linear(28*28, 256)\n",
     "        self.fc_mu = nn.Linear(256, latent_dim)\n",
     "        self.fc_logvar = nn.Linear(256, latent_dim)\n",
-    "        \n",
+    "\n",
     "        # Decoder\n",
     "        self.fc2 = nn.Linear(latent_dim, 256)\n",
     "        self.fc3 = nn.Linear(256, 28*28)\n",
-    "    \n",
+    "\n",
     "    def encode(self, x):\n",
     "        \"\"\"Encode input to latent distribution parameters.\"\"\"\n",
     "        h = F.relu(self.fc1(x))\n",
     "        mu = self.fc_mu(h)\n",
     "        logvar = self.fc_logvar(h)\n",
     "        return mu, logvar\n",
-    "    \n",
+    "\n",
     "    def reparameterize(self, mu, logvar):\n",
     "        \"\"\"Sample z from N(mu, sigma^2) using reparameterization trick.\"\"\"\n",
     "        std = torch.exp(0.5 * logvar)\n",
     "        eps = torch.randn_like(std)\n",
     "        z = mu + eps * std\n",
     "        return z\n",
-    "    \n",
+    "\n",
     "    def decode(self, z):\n",
     "        \"\"\"Decode latent code to reconstruction.\"\"\"\n",
     "        h = F.relu(self.fc2(z))\n",
     "        x_recon = torch.sigmoid(self.fc3(h))\n",
     "        return x_recon\n",
-    "    \n",
+    "\n",
     "    def forward(self, x):\n",
     "        mu, logvar = self.encode(x)\n",
     "        z = self.reparameterize(mu, logvar)\n",
@@ -634,16 +634,16 @@
     "def vae_loss(x_recon, x, mu, logvar, beta=1.0):\n",
     "    \"\"\"Compute VAE loss = reconstruction + beta * KL divergence.\"\"\"\n",
     "    batch_size = x.size(0)\n",
-    "    \n",
+    "\n",
     "    # Reconstruction loss (binary cross-entropy)\n",
     "    recon_loss = F.binary_cross_entropy(x_recon, x, reduction='sum') / batch_size\n",
-    "    \n",
+    "\n",
     "    # KL divergence: KL(N(mu, sigma^2) || N(0, 1))\n",
     "    # = 0.5 * sum(exp(logvar) + mu^2 - 1 - logvar)\n",
     "    kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) / batch_size\n",
-    "    \n",
+    "\n",
     "    total_loss = recon_loss + beta * kl_loss\n",
-    "    \n",
+    "\n",
     "    return total_loss, recon_loss, kl_loss"
    ]
   },
@@ -668,7 +668,7 @@
     "    model.eval()\n",
     "    z = torch.randn(n, model.latent_dim).to(device)\n",
     "    x_samples = model.decode(z).view(n, 1, 28, 28).cpu()\n",
-    "    \n",
+    "\n",
     "    fig, axes = plt.subplots(4, 4, figsize=(6, 6))\n",
     "    for i, ax in enumerate(axes.flat):\n",
     "        ax.imshow(x_samples[i, 0], cmap='gray')\n",
@@ -683,18 +683,18 @@
     "    model.eval()\n",
     "    x1 = x1.view(1, -1).to(device)\n",
     "    x2 = x2.view(1, -1).to(device)\n",
-    "    \n",
+    "\n",
     "    # Encode to latent space (use mean for cleaner interpolation)\n",
     "    mu1, _ = model.encode(x1)\n",
     "    mu2, _ = model.encode(x2)\n",
-    "    \n",
+    "\n",
     "    # Linear interpolation in latent space\n",
     "    alphas = torch.linspace(0, 1, steps)\n",
     "    latents = [(1 - alpha) * mu1 + alpha * mu2 for alpha in alphas]\n",
-    "    \n",
+    "\n",
     "    # Decode interpolated latents\n",
     "    images = [model.decode(z).view(28, 28).cpu() for z in latents]\n",
-    "    \n",
+    "\n",
     "    fig, axes = plt.subplots(1, steps, figsize=(1.5*steps, 2))\n",
     "    for i, ax in enumerate(axes):\n",
     "        ax.imshow(images[i], cmap='gray')\n",
@@ -712,7 +712,7 @@
     "    x_flat = x.view(x.size(0), -1)\n",
     "    x_recon, _, _ = model(x_flat)\n",
     "    x_recon = x_recon.view(-1, 1, 28, 28)\n",
-    "    \n",
+    "\n",
     "    fig, axes = plt.subplots(2, n, figsize=(1.5*n, 3))\n",
     "    for i in range(n):\n",
     "        axes[0, i].imshow(x[i, 0].cpu(), cmap='gray')\n",
@@ -776,22 +776,22 @@
     "    except StopIteration:\n",
     "        train_iter = iter(train_loader)\n",
     "        x, _ = next(train_iter)\n",
-    "    \n",
+    "\n",
     "    x = x.view(x.size(0), -1).to(device)\n",
-    "    \n",
+    "\n",
     "    # Forward pass\n",
     "    x_recon, mu, logvar = vae(x)\n",
     "    loss, recon, kl = vae_loss(x_recon, x, mu, logvar, beta=beta)\n",
-    "    \n",
+    "\n",
     "    # Backward pass\n",
     "    optimizer_vae.zero_grad()\n",
     "    loss.backward()\n",
     "    optimizer_vae.step()\n",
-    "    \n",
+    "\n",
     "    total_losses.append(loss.item())\n",
     "    recon_losses.append(recon.item())\n",
     "    kl_losses.append(kl.item())\n",
-    "    \n",
+    "\n",
     "    if step % 200 == 0:\n",
     "        print(f\"Step {step}/{num_steps} | Total: {loss.item():.2f} | Recon: {recon.item():.2f} | KL: {kl.item():.2f}\")\n",
     "\n",