Add files via upload

Fix terminal state check in 19.3 and 19.4, fix typo in 19.4

Blogs/BorealisODENumerical.ipynb

@@ -0,0 +1,432 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/udlbook/udlbook/blob/main/Blogs/BorealisODENumerical.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "JXsO7ce7oqeq"
+      },
+      "source": [
+        "# Numerical methods for ODEs\n",
+        "\n",
+        "This blog contains code that accompanies the RBC Borealis blog on numerical methods for ODEs. Contact udlbookmail@gmail.com if you find any problems."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AnvAKtP_oqes"
+      },
+      "source": [
+        "Import relevant libraries"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "UF-gJyZggyrl"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "szWLVrSSoqet"
+      },
+      "source": [
+        "Define the ODE that we will be experimenting with."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NkrGZLL6iM3P"
+      },
+      "outputs": [],
+      "source": [
+        "# The ODE that we will experiment with\n",
+        "def ode_lin_homog(t,x):\n",
+        "  return 0.5 * x ;\n",
+        "\n",
+        "# The derivative of the ODE function with respect to x (needed for Taylor's method)\n",
+        "def ode_lin_homog_deriv_x(t,x):\n",
+        "  return 0.5 ;\n",
+        "\n",
+        "# The derivative of the ODE function with respect to t (needed for Taylor's method)\n",
+        "def ode_lin_homog_deriv_t(t,x):\n",
+        "  return 0.0 ;\n",
+        "\n",
+        "# The closed form solution (so we can measure the error)\n",
+        "def ode_lin_homog_soln(t,C=0.5):\n",
+        "  return C * np.exp(0.5 * t) ;"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "In1C9wZkoqet"
+      },
+      "source": [
+        "This is a generic method that runs the numerical methods. It takes the initial conditions ($t_0$, $x_0$), the final time $t_1$ and the step size $h$.  It also takes the ODE function itself and its derivatives (only used for Taylor's method).  Finally, the parameter \"step_function\" is the method used to update (e.g., Euler's methods, Runge-Kutte 4-step)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VZfZDJAfmyrf"
+      },
+      "outputs": [],
+      "source": [
+        "def run_numerical(x_0, t_0, t_1, h, ode_func, ode_func_deriv_x, ode_func_deriv_t, ode_soln, step_function):\n",
+        "  x = [x_0]\n",
+        "  t = [t_0]\n",
+        "  while (t[-1] <= t_1):\n",
+        "    x = x+[step_function(x[-1],t[-1],h, ode_func, ode_func_deriv_x, ode_func_deriv_t)]\n",
+        "    t = t + [t[-1]+h]\n",
+        "\n",
+        "  # Returns x,y plot plus total numerical error at last point.\n",
+        "  return t, x, np.abs(ode_soln(t[-1])-x[-1])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Vfkc3-_7oqet"
+      },
+      "source": [
+        "Run the numerical method with step sizes of 2.0, 1.0, 0.5, 0.25, 0.125, 0.0675 and plot the results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1tyGbMZhoqeu"
+      },
+      "outputs": [],
+      "source": [
+        "def run_and_plot(ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function):\n",
+        "    # Specify the grid of points to draw the ODE\n",
+        "    t = np.arange(0.04, 4.0, 0.2)\n",
+        "    x = np.arange(0.04, 4.0, 0.2)\n",
+        "    T, X = np.meshgrid(t,x)\n",
+        "\n",
+        "    # ODE equation at these grid points (used to draw quiver-plot)\n",
+        "    dx = ode(T,X)\n",
+        "    dt = np.ones(dx.shape)\n",
+        "\n",
+        "    # The ground truth solution\n",
+        "    t2= np.arange(0,10,0.1)\n",
+        "    x2 = ode_solution(t2)\n",
+        "\n",
+        "    #####################################x_0, t_0, t_1, h #################################################\n",
+        "    t_sim1,x_sim1,error1 = run_numerical(0.5, 0.0, 4.0, 2.0000, ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "    t_sim2,x_sim2,error2 = run_numerical(0.5, 0.0, 4.0, 1.0000, ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "    t_sim3,x_sim3,error3 = run_numerical(0.5, 0.0, 4.0, 0.5000, ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "    t_sim4,x_sim4,error4 = run_numerical(0.5, 0.0, 4.0, 0.2500, ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "    t_sim5,x_sim5,error5 = run_numerical(0.5, 0.0, 4.0, 0.1250, ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "    t_sim6,x_sim6,error6 = run_numerical(0.5, 0.0, 4.0, 0.0675, ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "\n",
+        "    # Plot the ODE and ground truth solution\n",
+        "    fig,ax = plt.subplots()\n",
+        "    ax.quiver(T,X,dt,dx, scale=35.0)\n",
+        "    ax.plot(t2,x2,'r-')\n",
+        "\n",
+        "    # Plot the numerical approximations\n",
+        "    ax.plot(t_sim1,x_sim1,'.-',markeredgecolor='#773c23ff',markerfacecolor='#d18362', color='#d18362', markersize=10)\n",
+        "    ax.plot(t_sim2,x_sim2,'.-',markeredgecolor='#773c23ff',markerfacecolor='#d18362', color='#d18362', markersize=10)\n",
+        "    ax.plot(t_sim3,x_sim3,'.-',markeredgecolor='#773c23ff',markerfacecolor='#d18362', color='#d18362', markersize=10)\n",
+        "    ax.plot(t_sim4,x_sim4,'.-',markeredgecolor='#773c23ff',markerfacecolor='#d18362', color='#d18362', markersize=10)\n",
+        "    ax.plot(t_sim5,x_sim5,'.-',markeredgecolor='#773c23ff',markerfacecolor='#d18362', color='#d18362', markersize=10)\n",
+        "    ax.plot(t_sim6,x_sim6,'.-',markeredgecolor='#773c23ff',markerfacecolor='#d18362', color='#d18362', markersize=10)\n",
+        "\n",
+        "    ax.set_aspect('equal')\n",
+        "    ax.set_xlim(0,4)\n",
+        "    ax.set_ylim(0,4)\n",
+        "\n",
+        "    plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "JYrq8QIwvOIy"
+      },
+      "source": [
+        "# Euler Method\n",
+        "\n",
+        "Define the Euler method and set up functions for plotting."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "N73xMnCukVVX"
+      },
+      "outputs": [],
+      "source": [
+        "def euler_step(x_0, t_0, h, ode_func, ode_func_deriv_x=None, ode_func_deriv_t=None):\n",
+        "  return x_0 + h * ode_func(t_0, x_0) ;"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4B1_PGEcsZ9H"
+      },
+      "outputs": [],
+      "source": [
+        "run_and_plot(ode_lin_homog, None, None, ode_lin_homog_soln, euler_step)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FfwNihtkvJeX"
+      },
+      "source": [
+        "# Heun's Method"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "srHfNDcDxI1o"
+      },
+      "outputs": [],
+      "source": [
+        "def heun_step(x_0, t_0, h, ode_func, ode_func_deriv_x=None, ode_func_deriv_t=None):\n",
+        "  f_x0_t0 = ode_func(t_0, x_0)\n",
+        "  return x_0 + h/2 * ( f_x0_t0 + ode_func(t_0+h, x_0+h*f_x0_t0)) ;"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "WOApHz9xoqev"
+      },
+      "outputs": [],
+      "source": [
+        "run_and_plot(ode_lin_homog, None, None, ode_lin_homog_soln, heun_step)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0XSzzFDIvRhm"
+      },
+      "source": [
+        "# Modified Euler method"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "fSXprgVJ5Yep"
+      },
+      "outputs": [],
+      "source": [
+        "def modified_euler_step(x_0, t_0, h, ode_func, ode_func_deriv_x=None, ode_func_deriv_t=None):\n",
+        "  f_x0_t0 = ode_func(t_0, x_0)\n",
+        "  return x_0 + h * ode_func(t_0+h/2, x_0+ h * f_x0_t0/2) ;"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8LKSrCD2oqev"
+      },
+      "outputs": [],
+      "source": [
+        "run_and_plot(ode_lin_homog, None, None, ode_lin_homog_soln, modified_euler_step)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "yp8ZBpwooqev"
+      },
+      "source": [
+        "# Second order Taylor's method"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NtBBgzWLoqev"
+      },
+      "outputs": [],
+      "source": [
+        "def taylor_2nd_order(x_0, t_0, h, ode_func, ode_func_deriv_x, ode_func_deriv_t):\n",
+        "    f1 = ode_func(t_0, x_0)\n",
+        "    return x_0 + h * ode_func(t_0, x_0) + (h*h/2) * (ode_func_deriv_x(t_0,x_0) * ode_func(t_0, x_0) + ode_func_deriv_t(t_0, x_0))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ioeeIohUoqev"
+      },
+      "outputs": [],
+      "source": [
+        "run_and_plot(ode_lin_homog, ode_lin_homog_deriv_x, ode_lin_homog_deriv_t, ode_lin_homog_soln, taylor_2nd_order)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WcuhV5lL1zAJ"
+      },
+      "source": [
+        "# Fourth Order Runge Kutta"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "0NZN81Bpwu56"
+      },
+      "outputs": [],
+      "source": [
+        "def runge_kutta_4_step(x_0, t_0, h, ode_func, ode_func_deriv_x=None, ode_func_deriv_t=None):\n",
+        "    f1 = ode_func(t_0, x_0)\n",
+        "    f2 = ode_func(t_0+h/2,x_0+f1 * h/2)\n",
+        "    f3 = ode_func(t_0+h/2,x_0+f2 * h/2)\n",
+        "    f4 = ode_func(t_0+h, x_0+ f3*h)\n",
+        "    return x_0 + (h/6) * (f1 + 2*f2 + 2*f3+f4)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "K-OxE9E6oqew"
+      },
+      "outputs": [],
+      "source": [
+        "run_and_plot(ode_lin_homog, None, None, ode_lin_homog_soln, runge_kutta_4_step)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7JifxBhhoqew"
+      },
+      "source": [
+        "# Plot the error as a function of step size"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZoEpmlCfsi9P"
+      },
+      "outputs": [],
+      "source": [
+        "# Run systematically with a number of different step sizes and store errors for each\n",
+        "def get_errors(ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function):\n",
+        "    # Choose the step size h to divide the plotting interval into 1,2,4,8... segments.\n",
+        "    # The plots in the article add a few more smaller step sizes, but this takes a while to compute.\n",
+        "    # Add them back in if you want the full plot.\n",
+        "    all_h = (1./np.array([1,2,4,8,16,32,64,128,256,512,1024,2048,4096])).tolist()\n",
+        "    all_err = []\n",
+        "\n",
+        "    for i in range(len(all_h)):\n",
+        "        t_sim,x_sim,err = run_numerical(0.5, 0.0, 4.0, all_h[i], ode, ode_deriv_x, ode_deriv_t, ode_solution, step_function)\n",
+        "        all_err = all_err + [err]\n",
+        "\n",
+        "    return all_h, all_err"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "X0O0KK47xF28"
+      },
+      "outputs": [],
+      "source": [
+        "# Plot the errors\n",
+        "all_h, all_err_euler = get_errors(ode_lin_homog, ode_lin_homog_deriv_x, ode_lin_homog_deriv_t, ode_lin_homog_soln, euler_step)\n",
+        "all_h, all_err_heun = get_errors(ode_lin_homog, ode_lin_homog_deriv_x, ode_lin_homog_deriv_t, ode_lin_homog_soln, heun_step)\n",
+        "all_h, all_err_mod_euler = get_errors(ode_lin_homog, ode_lin_homog_deriv_x, ode_lin_homog_deriv_t, ode_lin_homog_soln, modified_euler_step)\n",
+        "all_h, all_err_taylor = get_errors(ode_lin_homog, ode_lin_homog_deriv_x, ode_lin_homog_deriv_t, ode_lin_homog_soln, taylor_2nd_order)\n",
+        "all_h, all_err_rk = get_errors(ode_lin_homog, ode_lin_homog_deriv_x, ode_lin_homog_deriv_t, ode_lin_homog_soln, runge_kutta_4_step)\n",
+        "\n",
+        "\n",
+        "fig, ax = plt.subplots()\n",
+        "ax.loglog(all_h, all_err_euler,'ro-')\n",
+        "ax.loglog(all_h, all_err_heun,'bo-')\n",
+        "ax.loglog(all_h, all_err_mod_euler,'go-')\n",
+        "ax.loglog(all_h, all_err_taylor,'co-')\n",
+        "ax.loglog(all_h, all_err_rk,'mo-')\n",
+        "ax.set_ylim(1e-13,1e1)\n",
+        "ax.set_xlim(1e-6,1e1)\n",
+        "ax.set_aspect(0.5)\n",
+        "ax.set_xlabel('Step size, $h$')\n",
+        "ax.set_ylabel('Error')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BttOqpeo9MsJ"
+      },
+      "source": [
+        "Note that for this ODE, the Heun, Modified Euler and Taylor methods provide EXACTLY the same updates, and so the error curves for all three are identical (subject to difference is numerical rounding errors).  This is not in general the case, although the general trend would be the same for each."
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.10"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Notebooks/Chap01/1_1_BackgroundMathematics.ipynb

@@ -295,7 +295,7 @@
         "\n",
         "Throughout the book, we'll be using some special functions (see Appendix B.1.3).  The most important of these are the logarithm and exponential functions.  Let's investigate their properties.\n",
         "\n",
-        "We'll start with the exponential function $y=\\exp[x]=e^x$ which maps the real line $[-\\infty,+\\infty]$ to non-negative numbers $[0,+\\infty]$."
+        "We'll start with the exponential function $y=\\exp[x]=e^x$ which maps the real line $(-\\infty,+\\infty)$ to positive numbers $(0,+\\infty)$."
       ]
     },
     {

Notebooks/Chap03/3_3_Shallow_Network_Regions.ipynb

@@ -4,7 +4,6 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "authorship_tag": "ABX9TyNioITtfAcfxEfM3UOfQyb9",
       "include_colab_link": true
     },
     "kernelspec": {
@@ -62,7 +61,7 @@
       "source": [
         "The number of regions $N$ created by a shallow neural network with $D_i$ inputs and $D$ hidden units is given by Zaslavsky's formula:\n",
         "\n",
-        "\\begin{equation}N = \\sum_{j=0}^{D_{i}}\\binom{D}{j}=\\sum_{j=0}^{D_{i}} \\frac{D!}{(D-j)!j!} \\end{equation} <br>\n",
+        "\\begin{equation}N = \\sum_{j=0}^{D_{i}}\\binom{D}{j}=\\sum_{j=0}^{D_{i}} \\frac{D!}{(D-j)!j!} \\end{equation} \n",
         "\n"
       ],
       "metadata": {
@@ -221,7 +220,7 @@
     {
       "cell_type": "code",
       "source": [
-        "# Now let's plot the graph from figure 3.9a (takes ~1min)\n",
+        "# Now let's plot the graph from figure 3.9b (takes ~1min)\n",
         "dims = np.array([1,5,10,50,100])\n",
         "regions = np.zeros((dims.shape[0], 200))\n",
         "params = np.zeros((dims.shape[0], 200))\n",

Notebooks/Chap04/4_2_Clipping_functions.ipynb

@@ -169,7 +169,7 @@
     {
       "cell_type": "code",
       "source": [
-        "# Define parameters (note first dimension of theta and phi is padded to make indices match\n",
+        "# Define parameters (note first dimension of theta and psi is padded to make indices match\n",
         "# notation in book)\n",
         "theta = np.zeros([4,2])\n",
         "psi = np.zeros([4,4])\n",

Notebooks/Chap04/4_3_Deep_Networks.ipynb

@@ -4,7 +4,6 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "authorship_tag": "ABX9TyO2DaD75p+LGi7WgvTzjrk1",
       "include_colab_link": true
     },
     "kernelspec": {
@@ -31,7 +30,7 @@
       "source": [
         "# **Notebook 4.3 Deep neural networks**\n",
         "\n",
-        "This network investigates converting neural networks to matrix form.\n",
+        "This notebook investigates converting neural networks to matrix form.\n",
         "\n",
         "Work through the cells below, running each cell in turn. In various places you will see the words \"TODO\". Follow the instructions at these places and make predictions about what is going to happen or write code to complete the functions.\n",
         "\n",
@@ -150,7 +149,7 @@
     {
       "cell_type": "markdown",
       "source": [
-        "Now we'll define the same neural network, but this time, we will  use matrix form.  When you get this right, it will draw the same plot as above."
+        "Now we'll define the same neural network, but this time, we will  use matrix form as in equation 4.15.  When you get this right, it will draw the same plot as above."
       ],
       "metadata": {
         "id": "XCJqo_AjfAra"
@@ -176,8 +175,8 @@
         "n1_in_mat = np.reshape(n1_in,(n_dim_in,n_data))\n",
         "\n",
         "# This runs the network for ALL of the inputs, x at once so we can draw graph\n",
-        "h1 = ReLU(np.matmul(beta_0,np.ones((1,n_data))) + np.matmul(Omega_0,n1_in_mat))\n",
+        "h1 = ReLU(beta_0 + np.matmul(Omega_0,n1_in_mat))\n",
-        "n1_out = np.matmul(beta_1,np.ones((1,n_data))) + np.matmul(Omega_1,h1)\n",
+        "n1_out = beta_1 + np.matmul(Omega_1,h1)\n",
         "\n",
         "# Draw the network and check that it looks the same as the non-matrix case\n",
         "plot_neural(n1_in, n1_out)"
@@ -247,9 +246,9 @@
         "n1_in_mat = np.reshape(n1_in,(n_dim_in,n_data))\n",
         "\n",
         "# This runs the network for ALL of the inputs, x at once so we can draw graph (hence extra np.ones term)\n",
-        "h1 = ReLU(np.matmul(beta_0,np.ones((1,n_data))) + np.matmul(Omega_0,n1_in_mat))\n",
+        "h1 = ReLU(beta_0 + np.matmul(Omega_0,n1_in_mat))\n",
-        "h2 = ReLU(np.matmul(beta_1,np.ones((1,n_data))) + np.matmul(Omega_1,h1))\n",
+        "h2 = ReLU(beta_1 + np.matmul(Omega_1,h1))\n",
-        "n1_out = np.matmul(beta_2,np.ones((1,n_data))) + np.matmul(Omega_2,h2)\n",
+        "n1_out = beta_2 + np.matmul(Omega_2,h2)\n",
         "\n",
         "# Draw the network and check that it looks the same as the non-matrix version\n",
         "plot_neural(n1_in, n1_out)"
@@ -291,10 +290,10 @@
         "\n",
         "\n",
         "# If you set the parameters to the correct sizes, the following code will run\n",
-        "h1 = ReLU(np.matmul(beta_0,np.ones((1,n_data))) + np.matmul(Omega_0,x));\n",
+        "h1 = ReLU(beta_0 + np.matmul(Omega_0,x));\n",
-        "h2 = ReLU(np.matmul(beta_1,np.ones((1,n_data))) + np.matmul(Omega_1,h1));\n",
+        "h2 = ReLU(beta_1 + np.matmul(Omega_1,h1));\n",
-        "h3 = ReLU(np.matmul(beta_2,np.ones((1,n_data))) + np.matmul(Omega_2,h2));\n",
+        "h3 = ReLU(beta_2 + np.matmul(Omega_2,h2));\n",
-        "y = np.matmul(beta_3,np.ones((1,n_data))) + np.matmul(Omega_3,h3)\n",
+        "y = beta_3 + np.matmul(Omega_3,h3)\n",
         "\n",
         "if h1.shape[0] is not D_1 or h1.shape[1] is not n_data:\n",
         "  print(\"h1 is wrong shape\")\n",

Notebooks/Chap05/5_3_Multiclass_Cross_entropy_Loss.ipynb

@@ -236,11 +236,10 @@
       },
       "outputs": [],
       "source": [
-        "# Let's double check we get the right answer before proceeding\n",
+        "# Here are three examples\n",
-        "print(\"Correct answer = %3.3f, Your answer = %3.3f\"%(0.2,categorical_distribution(np.array([[0]]),np.array([[0.2],[0.5],[0.3]]))))\n",
+        "print(categorical_distribution(np.array([[0]]),np.array([[0.2],[0.5],[0.3]])))\n",
-        "print(\"Correct answer = %3.3f, Your answer = %3.3f\"%(0.5,categorical_distribution(np.array([[1]]),np.array([[0.2],[0.5],[0.3]]))))\n",
+        "print(categorical_distribution(np.array([[1]]),np.array([[0.2],[0.5],[0.3]])))\n",
-        "print(\"Correct answer = %3.3f, Your answer = %3.3f\"%(0.3,categorical_distribution(np.array([[2]]),np.array([[0.2],[0.5],[0.3]]))))\n",
+        "print(categorical_distribution(np.array([[2]]),np.array([[0.2],[0.5],[0.3]])))"
-        "\n"
       ]
     },
     {

Notebooks/Chap06/6_2_Gradient_Descent.ipynb

@@ -301,7 +301,7 @@
       "source": [
         "def loss_function_1D(dist_prop, data, model, phi_start, search_direction):\n",
         "  # Return the loss after moving this far\n",
-        "  return compute_loss(data[0,:], data[1,:], model, phi_start+ search_direction * dist_prop)\n",
+        "  return compute_loss(data[0,:], data[1,:], model, phi_start - search_direction * dist_prop)\n",
         "\n",
         "def line_search(data, model, phi, gradient, thresh=.00001, max_dist = 0.1, max_iter = 15, verbose=False):\n",
         "    # Initialize four points along the range we are going to search\n",
@@ -365,7 +365,7 @@
         "def gradient_descent_step(phi, data,  model):\n",
         "  # TODO -- update Phi with the gradient descent step (equation 6.3)\n",
         "  # 1. Compute the gradient (you wrote this function above)\n",
-        "  # 2. Find the best step size alpha using line search function (above) -- use negative gradient as going downhill\n",
+        "  # 2. Find the best step size alpha using line search function (above)\n",
         "  # 3. Update the parameters phi based on the gradient and the step size alpha.\n",
         "\n",
         "  return phi"

Notebooks/Chap07/7_2_Backpropagation.ipynb

@@ -4,7 +4,6 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "authorship_tag": "ABX9TyM2kkHLr00J4Jeypw41sTkQ",
       "include_colab_link": true
     },
     "kernelspec": {
@@ -68,7 +67,7 @@
         "# Set seed so we always get the same random numbers\n",
         "np.random.seed(0)\n",
         "\n",
-        "# Number of layers\n",
+        "# Number of hidden layers\n",
         "K = 5\n",
         "# Number of neurons per layer\n",
         "D = 6\n",
@@ -115,7 +114,7 @@
     {
       "cell_type": "markdown",
       "source": [
-        "Now let's run our random network.  The weight matrices $\\boldsymbol\\Omega_{1\\ldots K}$ are the entries of the list \"all_weights\" and the biases $\\boldsymbol\\beta_{1\\ldots K}$ are the entries of the list \"all_biases\"\n",
+        "Now let's run our random network.  The weight matrices $\\boldsymbol\\Omega_{0\\ldots K}$ are the entries of the list \"all_weights\" and the biases $\\boldsymbol\\beta_{0\\ldots K}$ are the entries of the list \"all_biases\"\n",
         "\n",
         "We know that we will need the preactivations $\\mathbf{f}_{0\\ldots K}$ and the activations $\\mathbf{h}_{1\\ldots K}$ for the forward pass of backpropagation, so we'll store and return these as well.\n"
       ],
@@ -142,7 +141,7 @@
         "\n",
         "  # Run through the layers, calculating all_f[0...K-1] and all_h[1...K]\n",
         "  for layer in range(K):\n",
-        "      # Update preactivations and activations at this layer according to eqn 7.16\n",
+        "      # Update preactivations and activations at this layer according to eqn 7.17\n",
         "      # Remember to use np.matmul for matrix multiplications\n",
         "      # TODO -- Replace the lines below\n",
         "      all_f[layer] = all_h[layer]\n",
@@ -230,8 +229,8 @@
         "# We'll need the indicator function\n",
         "def indicator_function(x):\n",
         "  x_in = np.array(x)\n",
-        "  x_in[x_in>=0] = 1\n",
+        "  x_in[x_in>0] = 1\n",
-        "  x_in[x_in<0] = 0\n",
+        "  x_in[x_in<=0] = 0\n",
         "  return x_in\n",
         "\n",
         "# Main backward pass routine\n",
@@ -249,23 +248,23 @@
         "\n",
         "  # Now work backwards through the network\n",
         "  for layer in range(K,-1,-1):\n",
-        "    # TODO Calculate the derivatives of the loss with respect to the biases at layer from all_dl_df[layer]. (eq 7.21)\n",
+        "    # TODO Calculate the derivatives of the loss with respect to the biases at layer from all_dl_df[layer]. (eq 7.22)\n",
         "    # NOTE!  To take a copy of matrix X, use Z=np.array(X)\n",
         "    # REPLACE THIS LINE\n",
         "    all_dl_dbiases[layer] = np.zeros_like(all_biases[layer])\n",
         "\n",
-        "    # TODO Calculate the derivatives of the loss with respect to the weights at layer from all_dl_df[layer] and all_h[layer] (eq 7.22)\n",
+        "    # TODO Calculate the derivatives of the loss with respect to the weights at layer from all_dl_df[layer] and all_h[layer] (eq 7.23)\n",
         "    # Don't forget to use np.matmul\n",
         "    # REPLACE THIS LINE\n",
         "    all_dl_dweights[layer] = np.zeros_like(all_weights[layer])\n",
         "\n",
-        "    # TODO: calculate the derivatives of the loss with respect to the activations from weight and derivatives of next preactivations (second part of last line of eq 7.24)\n",
+        "    # TODO: calculate the derivatives of the loss with respect to the activations from weight and derivatives of next preactivations (second part of last line of eq 7.25)\n",
         "    # REPLACE THIS LINE\n",
         "    all_dl_dh[layer] = np.zeros_like(all_h[layer])\n",
         "\n",
         "\n",
         "    if layer > 0:\n",
-        "      # TODO Calculate the derivatives of the loss with respect to the pre-activation f (use derivative of ReLu function, first part of last line of eq. 7.24)\n",
+        "      # TODO Calculate the derivatives of the loss with respect to the pre-activation f (use derivative of ReLu function, first part of last line of eq. 7.25)\n",
         "      # REPLACE THIS LINE\n",
         "      all_dl_df[layer-1] = np.zeros_like(all_f[layer-1])\n",
         "\n",
@@ -300,7 +299,7 @@
         "delta_fd = 0.000001\n",
         "\n",
         "# Test the dervatives of the bias vectors\n",
-        "for layer in range(K):\n",
+        "for layer in range(K+1):\n",
         "  dl_dbias  = np.zeros_like(all_dl_dbiases[layer])\n",
         "  # For every element in the bias\n",
         "  for row in range(all_biases[layer].shape[0]):\n",
@@ -324,7 +323,7 @@
         "\n",
         "\n",
         "# Test the derivatives of the weights matrices\n",
-        "for layer in range(K):\n",
+        "for layer in range(K+1):\n",
         "  dl_dweight  = np.zeros_like(all_dl_dweights[layer])\n",
         "  # For every element in the bias\n",
         "  for row in range(all_weights[layer].shape[0]):\n",

Notebooks/Chap07/7_3_Initialization.ipynb

@@ -325,7 +325,7 @@
         "  for layer in range(1,K):\n",
         "    aggregate_dl_df[layer][:,c_data] = np.squeeze(all_dl_df[layer])\n",
         "\n",
-        "for layer in range(1,K):\n",
+        "for layer in reversed(range(1,K)):\n",
         "  print(\"Layer %d, std of dl_dh = %3.3f\"%(layer, np.std(aggregate_dl_df[layer].ravel())))\n"
       ],
       "metadata": {

Notebooks/Chap08/8_2_Bias_Variance_Trade_Off.ipynb

@@ -293,7 +293,8 @@
       "cell_type": "code",
       "source": [
         "# Plot the noise, bias and variance as a function of capacity\n",
-        "hidden_variables = [1,2,3,4,5,6,7,8,9,10,11,12]\n",
+        "n_hidden = 12\n",
+        "hidden_variables = list(range(1, n_hidden + 1))\n",
         "bias = np.zeros((len(hidden_variables),1)) ;\n",
         "variance = np.zeros((len(hidden_variables),1)) ;\n",
         "\n",
@@ -321,7 +322,7 @@
         "ax.plot(hidden_variables, variance, 'k-')\n",
         "ax.plot(hidden_variables, bias, 'r-')\n",
         "ax.plot(hidden_variables, variance+bias, 'g-')\n",
-        "ax.set_xlim(0,12)\n",
+        "ax.set_xlim(0,n_hidden)\n",
         "ax.set_ylim(0,0.5)\n",
         "ax.set_xlabel(\"Model capacity\")\n",
         "ax.set_ylabel(\"Variance\")\n",
@@ -333,15 +334,6 @@
       },
       "execution_count": null,
       "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [],
-      "metadata": {
-        "id": "WKUyOAywL_b2"
-      },
-      "execution_count": null,
-      "outputs": []
     }
   ]
 }

Notebooks/Chap09/9_1_L2_Regularization.ipynb

@@ -4,7 +4,6 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "authorship_tag": "ABX9TyPJzymRTuvoWggIskM2Kamc",
       "include_colab_link": true
     },
     "kernelspec": {
@@ -458,14 +457,14 @@
     {
       "cell_type": "code",
       "source": [
-        "def dldphi0(phi, lambda_):\n",
+        "def dregdphi0(phi, lambda_):\n",
         "  # TODO compute the derivative with respect to phi0\n",
         "  # Replace this line:]\n",
         "  deriv = 0\n",
         "\n",
         "  return deriv\n",
         "\n",
-        "def dldphi1(phi, lambda_):\n",
+        "def dregdphi1(phi, lambda_):\n",
         "  # TODO compute the derivative with respect to phi1\n",
         "  # Replace this line:]\n",
         "  deriv = 0\n",
@@ -475,8 +474,8 @@
         "\n",
         "\n",
         "def compute_gradient2(data_x, data_y, phi, lambda_):\n",
-        "    dl_dphi0 = gabor_deriv_phi0(data_x, data_y, phi[0],phi[1])+dldphi0(np.squeeze(phi), lambda_)\n",
+        "    dl_dphi0 = gabor_deriv_phi0(data_x, data_y, phi[0],phi[1])+dregdphi0(np.squeeze(phi), lambda_)\n",
-        "    dl_dphi1 = gabor_deriv_phi1(data_x, data_y, phi[0],phi[1])+dldphi1(np.squeeze(phi), lambda_)\n",
+        "    dl_dphi1 = gabor_deriv_phi1(data_x, data_y, phi[0],phi[1])+dregdphi1(np.squeeze(phi), lambda_)\n",
         "    # Return the gradient\n",
         "    return np.array([[dl_dphi0],[dl_dphi1]])\n",
         "\n",

Notebooks/Chap09/9_4_Bayesian_Approach.ipynb

@@ -342,7 +342,7 @@
         "[\\mathbf{h}^*;1]\\biggr],\n",
         "\\end{align}\n",
         "\n",
-        "where the notation $[\\mathbf{h}^{*T},1]$ is a row vector containing $\\mathbf{h}^{T}$ with a one appended to the end and $[\\mathbf{h};1 ]$ is a column vector containing $\\mathbf{h}$ with a one appended to the end.\n",
+        "where the notation $[\\mathbf{h}^{*T},1]$ is a row vector containing $\\mathbf{h}^{*T}$ with a one appended to the end and $[\\mathbf{h}^{*};1 ]$ is a column vector containing $\\mathbf{h}^{*}$ with a one appended to the end.\n",
         "\n",
         "\n",
         "To compute this, we reformulated the integrand using the relations from appendices C.3.3 and C.3.4 as the product of a normal distribution in $\\boldsymbol\\phi$ and a constant with respect\n",

Notebooks/Chap10/10_4_Downsampling_and_Upsampling.ipynb

@@ -4,7 +4,6 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "authorship_tag": "ABX9TyMbSR8fzpXvO6TIQdO7bI0H",
       "include_colab_link": true
     },
     "kernelspec": {
@@ -31,7 +30,7 @@
       "source": [
         "# **Notebook 10.4: Downsampling and Upsampling**\n",
         "\n",
-        "This notebook investigates the down sampling and downsampling methods discussed in section 10.4 of the book.\n",
+        "This notebook investigates the upsampling and downsampling methods discussed in section 10.4 of the book.\n",
         "\n",
         "Work through the cells below, running each cell in turn. In various places you will see the words \"TODO\". Follow the instructions at these places and make predictions about what is going to happen or write code to complete the functions.\n",
         "\n",
@@ -71,9 +70,9 @@
     {
       "cell_type": "code",
       "source": [
-        "def subsample(x_in):\n",
+        "def downsample(x_in):\n",
         "  x_out = np.zeros(( int(np.ceil(x_in.shape[0]/2)), int(np.ceil(x_in.shape[1]/2)) ))\n",
-        "  # TO DO -- write the subsampling routine\n",
+        "  # TODO -- write the downsampling routine\n",
         "  # Replace this line\n",
         "  x_out = x_out\n",
         "\n",
@@ -91,8 +90,8 @@
       "source": [
         "print(\"Original:\")\n",
         "print(orig_4_4)\n",
-        "print(\"Subsampled:\")\n",
+        "print(\"Downsampled:\")\n",
-        "print(subsample(orig_4_4))"
+        "print(downsample(orig_4_4))"
       ],
       "metadata": {
         "id": "O_i0y72_JwGZ"
@@ -127,24 +126,24 @@
         "image = Image.open('test_image.png')\n",
         "# convert image to numpy array\n",
         "data = asarray(image)\n",
-        "data_subsample = subsample(data);\n",
+        "data_downsample = downsample(data);\n",
         "\n",
         "plt.figure(figsize=(5,5))\n",
         "plt.imshow(data, cmap='gray')\n",
         "plt.show()\n",
         "\n",
         "plt.figure(figsize=(5,5))\n",
-        "plt.imshow(data_subsample, cmap='gray')\n",
+        "plt.imshow(data_downsample, cmap='gray')\n",
         "plt.show()\n",
         "\n",
-        "data_subsample2 = subsample(data_subsample)\n",
+        "data_downsample2 = downsample(data_downsample)\n",
         "plt.figure(figsize=(5,5))\n",
-        "plt.imshow(data_subsample2, cmap='gray')\n",
+        "plt.imshow(data_downsample2, cmap='gray')\n",
         "plt.show()\n",
         "\n",
-        "data_subsample3 = subsample(data_subsample2)\n",
+        "data_downsample3 = downsample(data_downsample2)\n",
         "plt.figure(figsize=(5,5))\n",
-        "plt.imshow(data_subsample3, cmap='gray')\n",
+        "plt.imshow(data_downsample3, cmap='gray')\n",
         "plt.show()"
       ],
       "metadata": {
@@ -345,11 +344,11 @@
     {
       "cell_type": "code",
       "source": [
-        "# Let's re-upsample, sub-sampled rick\n",
+        "# Let's re-upsample, downsampled rick\n",
-        "data_duplicate = duplicate(data_subsample3);\n",
+        "data_duplicate = duplicate(data_downsample3);\n",
         "\n",
         "plt.figure(figsize=(5,5))\n",
-        "plt.imshow(data_subsample3, cmap='gray')\n",
+        "plt.imshow(data_downsample3, cmap='gray')\n",
         "plt.show()\n",
         "\n",
         "plt.figure(figsize=(5,5))\n",
@@ -388,7 +387,7 @@
         "# The input x_high_res is the original high res image, from which you can deduce the position of the maximum index\n",
         "def max_unpool(x_in, x_high_res):\n",
         "  x_out = np.zeros(( x_in.shape[0]*2, x_in.shape[1]*2 ))\n",
-        "  # TO DO -- write the subsampling routine\n",
+        "  # TODO -- write the unpooling routine\n",
         "  # Replace this line\n",
         "  x_out = x_out\n",
         "\n",
@@ -417,7 +416,7 @@
     {
       "cell_type": "code",
       "source": [
-        "# Let's re-upsample, sub-sampled rick\n",
+        "# Let's re-upsample, down-sampled rick\n",
         "data_max_unpool= max_unpool(data_maxpool3,data_maxpool2);\n",
         "\n",
         "plt.figure(figsize=(5,5))\n",
@@ -489,7 +488,7 @@
     {
       "cell_type": "code",
       "source": [
-        "# Let's re-upsample, sub-sampled rick\n",
+        "# Let's re-upsample, down-sampled rick\n",
         "data_bilinear = bilinear(data_meanpool3);\n",
         "\n",
         "plt.figure(figsize=(5,5))\n",

Notebooks/Chap10/10_5_Convolution_For_MNIST.ipynb

@@ -1,26 +1,10 @@
 {
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": [],
-      "authorship_tag": "ABX9TyNELb86uz5qbhEKH81UqFKT",
-      "include_colab_link": true
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
   "cells": [
     {
       "cell_type": "markdown",
       "metadata": {
-        "id": "view-in-github",
+        "colab_type": "text",
-        "colab_type": "text"
+        "id": "view-in-github"
       },
       "source": [
         "<a href=\"https://colab.research.google.com/github/udlbook/udlbook/blob/main/Notebooks/Chap10/10_5_Convolution_For_MNIST.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
@@ -28,6 +12,9 @@
     },
     {
       "cell_type": "markdown",
+      "metadata": {
+        "id": "t9vk9Elugvmi"
+      },
       "source": [
         "# **Notebook 10.5: Convolution for MNIST**\n",
         "\n",
@@ -37,14 +24,18 @@
         "\n",
         "Work through the cells below, running each cell in turn. In various places you will see the words \"TODO\". Follow the instructions at these places and make predictions about what is going to happen or write code to complete the functions.\n",
         "\n",
+        "If you are using Google Colab, you can change your runtime to an instance with GPU support to speed up training, e.g. a T4 GPU. If you do this, the cell below should output ``device(type='cuda')``\n",
+        "\n",
         "Contact me at udlbookmail@gmail.com if you find any mistakes or have any suggestions.\n"
-      ],
+      ]
-      "metadata": {
-        "id": "t9vk9Elugvmi"
-      }
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YrXWAH7sUWvU"
+      },
+      "outputs": [],
       "source": [
         "import torch\n",
         "import torchvision\n",
@@ -52,16 +43,18 @@
         "import torch.nn.functional as F\n",
         "import torch.optim as optim\n",
         "import matplotlib.pyplot as plt\n",
-        "import random"
+        "import random\n",
-      ],
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-      "metadata": {
+        "device"
-        "id": "YrXWAH7sUWvU"
+      ]
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "wScBGXXFVadm"
+      },
+      "outputs": [],
       "source": [
         "# Run this once to load the train and test data straight into a dataloader class\n",
         "# that will provide the batches\n",
@@ -72,8 +65,12 @@
         "# even before you make changes.\n",
         "batch_size_train = 64\n",
         "batch_size_test = 1000\n",
+        "\n",
+        "# TODO Change this directory to point towards an existing directory (No change needed if using Google Colab)\n",
+        "myDir = '/files/'\n",
+        "\n",
         "train_loader = torch.utils.data.DataLoader(\n",
-        "  torchvision.datasets.MNIST('/files/', train=True, download=True,\n",
+        "  torchvision.datasets.MNIST(myDir, train=True, download=True,\n",
         "                             transform=torchvision.transforms.Compose([\n",
         "                               torchvision.transforms.ToTensor(),\n",
         "                               torchvision.transforms.Normalize(\n",
@@ -82,31 +79,22 @@
         "  batch_size=batch_size_train, shuffle=True)\n",
         "\n",
         "test_loader = torch.utils.data.DataLoader(\n",
-        "  torchvision.datasets.MNIST('/files/', train=False, download=True,\n",
+        "  torchvision.datasets.MNIST(myDir, train=False, download=True,\n",
         "                             transform=torchvision.transforms.Compose([\n",
         "                               torchvision.transforms.ToTensor(),\n",
         "                               torchvision.transforms.Normalize(\n",
         "                                 (0.1307,), (0.3081,))\n",
         "                             ])),\n",
         "  batch_size=batch_size_test, shuffle=True)"
-      ],
+      ]
-      "metadata": {
-        "id": "wScBGXXFVadm"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
-      "source": [],
-      "metadata": {
-        "id": "YGwbxJDEm88i"
-      },
       "execution_count": null,
-      "outputs": []
+      "metadata": {
+        "id": "8bKADvLHbiV5"
       },
-    {
+      "outputs": [],
-      "cell_type": "code",
       "source": [
         "# Let's draw some of the training data\n",
         "examples = enumerate(test_loader)\n",
@@ -121,24 +109,24 @@
         "  plt.xticks([])\n",
         "  plt.yticks([])\n",
         "plt.show()"
-      ],
+      ]
-      "metadata": {
-        "id": "8bKADvLHbiV5"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Define the network.  This is a more typical way to define a network than the sequential structure.  We define a class for the network, and define the parameters in the constructor.  Then we use a function called forward to actually run the network.  It's easy to see how you might use residual connections in this format."
-      ],
       "metadata": {
         "id": "_sFvRDGrl4qe"
-      }
+      },
+      "source": [
+        "Define the network.  This is a more typical way to define a network than the sequential structure.  We define a class for the network, and define the parameters in the constructor.  Then we use a function called forward to actually run the network.  It's easy to see how you might use residual connections in this format."
+      ]
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "EQkvw2KOPVl7"
+      },
+      "outputs": [],
       "source": [
         "from os import X_OK\n",
         "# TODO Change this class to implement\n",
@@ -179,52 +167,54 @@
         "\n",
         "\n",
         "\n"
-      ],
+      ]
-      "metadata": {
-        "id": "EQkvw2KOPVl7"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qWZtkCZcU_dg"
+      },
+      "outputs": [],
       "source": [
         "# He initialization of weights\n",
         "def weights_init(layer_in):\n",
         "  if isinstance(layer_in, nn.Linear):\n",
         "    nn.init.kaiming_uniform_(layer_in.weight)\n",
         "    layer_in.bias.data.fill_(0.0)"
-      ],
+      ]
-      "metadata": {
-        "id": "qWZtkCZcU_dg"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "FslroPJJffrh"
+      },
+      "outputs": [],
       "source": [
         "# Create network\n",
-        "model = Net()\n",
+        "model = Net().to(device)\n",
         "# Initialize model weights\n",
         "model.apply(weights_init)\n",
         "# Define optimizer\n",
         "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)"
-      ],
+      ]
-      "metadata": {
-        "id": "FslroPJJffrh"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xKQd9PzkQ766"
+      },
+      "outputs": [],
       "source": [
         "# Main training routine\n",
         "def train(epoch):\n",
         "  model.train()\n",
         "  # Get each\n",
         "  for batch_idx, (data, target) in enumerate(train_loader):\n",
+        "    data = data.to(device)\n",
+        "    target = target.to(device)\n",
         "    optimizer.zero_grad()\n",
         "    output = model(data)\n",
         "    loss = F.nll_loss(output, target)\n",
@@ -234,15 +224,15 @@
         "    if batch_idx % 10 == 0:\n",
         "      print('Train Epoch: {} [{}/{}]\\tLoss: {:.6f}'.format(\n",
         "        epoch, batch_idx * len(data), len(train_loader.dataset), loss.item()))"
-      ],
+      ]
-      "metadata": {
-        "id": "xKQd9PzkQ766"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Byn-f7qWRLxX"
+      },
+      "outputs": [],
       "source": [
         "# Run on test data\n",
         "def test():\n",
@@ -251,6 +241,8 @@
         "  correct = 0\n",
         "  with torch.no_grad():\n",
         "    for data, target in test_loader:\n",
+        "      data = data.to(device)\n",
+        "      target = target.to(device)\n",
         "      output = model(data)\n",
         "      test_loss += F.nll_loss(output, target, size_average=False).item()\n",
         "      pred = output.data.max(1, keepdim=True)[1]\n",
@@ -259,15 +251,15 @@
         "  print('\\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
         "    test_loss, correct, len(test_loader.dataset),\n",
         "    100. * correct / len(test_loader.dataset)))"
-      ],
+      ]
-      "metadata": {
-        "id": "Byn-f7qWRLxX"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YgLaex1pfhqz"
+      },
+      "outputs": [],
       "source": [
         "# Get initial performance\n",
         "test()\n",
@@ -276,15 +268,15 @@
         "for epoch in range(1, n_epochs + 1):\n",
         "  train(epoch)\n",
         "  test()"
-      ],
+      ]
-      "metadata": {
-        "id": "YgLaex1pfhqz"
-      },
-      "execution_count": null,
-      "outputs": []
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "o7fRUAy9Se1B"
+      },
+      "outputs": [],
       "source": [
         "# Run network on data we got before and show predictions\n",
         "output = model(example_data)\n",
@@ -299,12 +291,23 @@
         "  plt.xticks([])\n",
         "  plt.yticks([])\n",
         "plt.show()"
-      ],
-      "metadata": {
-        "id": "o7fRUAy9Se1B"
-      },
-      "execution_count": null,
-      "outputs": []
-    }
       ]
     }
+  ],
+  "metadata": {
+    "colab": {
+      "authorship_tag": "ABX9TyORZF8xy4X1yf4oRhRq8Rtm",
+      "include_colab_link": true,
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Notebooks/Chap11/11_1_Shattered_Gradients.ipynb

@@ -65,7 +65,7 @@
     {
       "cell_type": "code",
       "source": [
-        "# K is width, D is number of hidden units in each layer\n",
+        "# K is depth, D is number of hidden units in each layer\n",
         "def init_params(K, D):\n",
         "  # Set seed so we always get the same random numbers\n",
         "  np.random.seed(1)\n",

Notebooks/Chap15/15_2_Wasserstein_Distance.ipynb

@@ -86,6 +86,7 @@
       "cell_type": "code",
       "source": [
         "# TODO Define the distance matrix from figure 15.8d\n",
+        "# The index should be normalized before being used in the distance calculation.\n",
         "# Replace this line\n",
         "dist_mat = np.zeros((10,10))\n",
         "\n",

Notebooks/Chap17/17_1_Latent_Variable_Models.ipynb

@@ -1,18 +1,16 @@
 {
   "cells": [
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
-        "colab_type": "text",
+        "id": "view-in-github",
-        "id": "view-in-github"
+        "colab_type": "text"
       },
       "source": [
         "<a href=\"https://colab.research.google.com/github/udlbook/udlbook/blob/main/Notebooks/Chap17/17_1_Latent_Variable_Models.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "t9vk9Elugvmi"
@@ -43,7 +41,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "IyVn-Gi-p7wf"
@@ -79,7 +76,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "KB9FU34onW1j"
@@ -145,7 +141,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "sQg2gKR5zMrF"
@@ -223,7 +218,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "0X4NwixzqxtZ"
@@ -254,7 +248,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "25xqXnmFo-PH"
@@ -281,7 +274,7 @@
         "# We can't integrate this function in closed form\n",
         "# So let's approximate it as a sum over the z values (z = np.arange(-3,3,0.01))\n",
         "# You will need the functions get_likelihood() and get_prior()\n",
-        "# To make this a valid probability distribution, you need to divide\n",
+        "# To make this a valid probability distribution, you need to multiply\n",
         "# By the z-increment (0.01)\n",
         "# Replace this line\n",
         "pr_x1_x2 = np.zeros_like(x1_mesh)\n",
@@ -292,7 +285,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "W264N7By_h9y"
@@ -320,7 +312,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "D7N7oqLe-eJO"
@@ -388,9 +379,8 @@
   ],
   "metadata": {
     "colab": {
-      "authorship_tag": "ABX9TyOSEQVqxE5KrXmsZVh9M3gq",
+      "provenance": [],
-      "include_colab_link": true,
+      "include_colab_link": true
-      "provenance": []
     },
     "kernelspec": {
       "display_name": "Python 3",

Notebooks/Chap17/17_3_Importance_Sampling.ipynb

@@ -1,18 +1,16 @@
 {
   "cells": [
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
-        "colab_type": "text",
+        "id": "view-in-github",
-        "id": "view-in-github"
+        "colab_type": "text"
       },
       "source": [
         "<a href=\"https://colab.research.google.com/github/udlbook/udlbook/blob/main/Notebooks/Chap17/17_3_Importance_Sampling.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "t9vk9Elugvmi"
@@ -40,7 +38,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "f7a6xqKjkmvT"
@@ -126,7 +123,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "Jr4UPcqmnXCS"
@@ -166,8 +162,8 @@
         "mean_all = np.zeros_like(n_sample_all)\n",
         "variance_all = np.zeros_like(n_sample_all)\n",
         "for i in range(len(n_sample_all)):\n",
-        "  print(\"Computing mean and variance for expectation with %d samples\"%(n_sample_all[i]))\n",
+        "  mean_all[i],variance_all[i] = compute_mean_variance(n_sample_all[i])\n",
-        "  mean_all[i],variance_all[i] = compute_mean_variance(n_sample_all[i])"
+        "  print(\"No samples: \", n_sample_all[i], \", Mean: \", mean_all[i], \", Variance: \", variance_all[i])"
       ]
     },
     {
@@ -189,7 +185,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "XTUpxFlSuOl7"
@@ -199,7 +194,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "6hxsl3Pxo1TT"
@@ -234,7 +228,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "G9Xxo0OJsIqD"
@@ -283,7 +276,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "2sVDqP0BvxqM"
@@ -313,8 +305,8 @@
         "mean_all2 = np.zeros_like(n_sample_all)\n",
         "variance_all2 = np.zeros_like(n_sample_all)\n",
         "for i in range(len(n_sample_all)):\n",
-        "  print(\"Computing variance for expectation with %d samples\"%(n_sample_all[i]))\n",
+        "  mean_all2[i], variance_all2[i] = compute_mean_variance2(n_sample_all[i])\n",
-        "  mean_all2[i], variance_all2[i] = compute_mean_variance2(n_sample_all[i])"
+        "  print(\"No samples: \", n_sample_all[i], \", Mean: \", mean_all2[i], \", Variance: \", variance_all2[i])"
       ]
     },
     {
@@ -348,7 +340,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "EtBP6NeLwZqz"
@@ -360,7 +351,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "_wuF-NoQu1--"
@@ -432,8 +422,8 @@
         "mean_all2b = np.zeros_like(n_sample_all)\n",
         "variance_all2b = np.zeros_like(n_sample_all)\n",
         "for i in range(len(n_sample_all)):\n",
-        "  print(\"Computing variance for expectation with %d samples\"%(n_sample_all[i]))\n",
+        "  mean_all2b[i], variance_all2b[i] = compute_mean_variance2b(n_sample_all[i])\n",
-        "  mean_all2b[i], variance_all2b[i] = compute_mean_variance2b(n_sample_all[i])"
+        "  print(\"No samples: \", n_sample_all[i], \", Mean: \", mean_all2b[i], \", Variance: \", variance_all2b[i])"
       ]
     },
     {
@@ -478,7 +468,6 @@
       ]
     },
     {
-      "attachments": {},
       "cell_type": "markdown",
       "metadata": {
         "id": "y8rgge9MNiOc"
@@ -490,9 +479,8 @@
   ],
   "metadata": {
     "colab": {
-      "authorship_tag": "ABX9TyNecz9/CDOggPSmy1LjT/Dv",
+      "provenance": [],
-      "include_colab_link": true,
+      "include_colab_link": true
-      "provenance": []
     },
     "kernelspec": {
       "display_name": "Python 3",

Notebooks/Chap19/19_2_Dynamic_Programming.ipynb

@@ -4,7 +4,6 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "authorship_tag": "ABX9TyOlD6kmCxX3SKKuh3oJikKA",
       "include_colab_link": true
     },
     "kernelspec": {
@@ -406,6 +405,10 @@
         "            state_values_new[state] = 3.0\n",
         "            break\n",
         "\n",
+        "        # TODO -- Write this function (from equation 19.11, but bear in mind policy is deterministic here)\n",
+        "        # Replace this line\n",
+        "        state_values_new[state] = 0\n",
+        "\n",
         "    return state_values_new\n",
         "\n",
         "# Greedily choose the action that maximizes the value for each state.\n",

Notebooks/Chap19/19_3_Monte_Carlo_Methods.ipynb

@@ -437,7 +437,7 @@
         "  new_state = np.random.choice(a=np.arange(0,transition_probabilities_given_action.shape[0]),p = transition_probabilities_given_action[:,state,action])\n",
         "  # Return the reward\n",
         "  reward = reward_structure[new_state]\n",
-        "  is_terminal = new_state in [terminal_states]\n",
+        "  is_terminal = new_state in terminal_states\n",
         "\n",
         "  return new_state, reward, action, is_terminal"
       ]

Notebooks/Chap19/19_4_Temporal_Difference_Methods.ipynb

@@ -265,7 +265,7 @@
         "\n",
         "In this icy environment the penguin is at one of the discrete cells in the gridworld. The agent starts each episode on a randomly chosen cell. The environment state dynamics are captured by the transition probabilities $Pr(s_{t+1} |s_t, a_t)$ where $s_t$ is the current state, $a_t$ is the action chosen, and $s_{t+1}$ is the next state at decision stage t. At each decision stage, the penguin can move in one of four directions: $a=0$ means try to go upward, $a=1$, right, $a=2$ down and $a=3$ left.\n",
         "\n",
-        "However, the ice is slippery, so we don't always go the direction we want to: every time the agent chooses an action, with 0.25 probability, the environment changes the action taken to a differenct action, which is uniformly sampled from the other available actions.\n",
+        "However, the ice is slippery, so we don't always go the direction we want to: every time the agent chooses an action, with 0.25 probability, the environment changes the action taken to a different action, which is uniformly sampled from the other available actions.\n",
         "\n",
         "The rewards are deterministic; the penguin will receive a reward of +3 if it reaches the fish, -2 if it slips into a hole and 0 otherwise.\n",
         "\n",
@@ -470,7 +470,7 @@
         "\n",
         "  # Return the reward -- here the reward is for arriving at the state\n",
         "  reward = reward_structure[new_state]\n",
-        "  is_terminal = new_state in [terminal_states]\n",
+        "  is_terminal = new_state in terminal_states\n",
         "\n",
         "  return new_state, reward, action, is_terminal"
       ]

src/components/HeroSection/index.jsx

@@ -33,6 +33,124 @@ const citation = `
     `;
 
 const news = [
+    {
+        // date: "03/6/25",
+        // content: (
+        //     <HeroNewsItemContent>
+        //         New {" "}
+        //         <UDLLink href="https://dl4ds.github.io/sp2025/lectures/">
+        //             slides and video lectures
+        //         </UDLLink>{" "}
+        //         that closely follow the book from Thomas Gardos of Boston University.
+        //     </HeroNewsItemContent>
+        // ),
+    },
+    {
+        date: "02/19/25",
+        content: (
+            <HeroNewsItemContent>
+                Three new blogs {" "}
+                <UDLLink href="https://rbcborealis.com/research-blogs/odes-and-sdes-for-machine-learning/">
+                    [1]
+                </UDLLink>
+                <UDLLink href="https://rbcborealis.com/research-blogs/introduction-ordinary-differential-equations/">
+                    [2]
+                </UDLLink>
+                <UDLLink href="https://rbcborealis.com/research-blogs/closed-form-solutions-for-odes/">
+                    [3]
+                </UDLLink>{" "}
+                on ODEs and SDEs in machine learning.
+            </HeroNewsItemContent>
+        ),
+    },
+    {
+        date: "01/23/25",
+        content: (
+            <HeroNewsItemContent>
+                Added{" "}
+                <UDLLink href="https://github.com/udlbook/udlbook/raw/main/understanding-deep-learning-final.bib">
+                    bibfile 
+                </UDLLink>{" "} for book and
+                <UDLLink href="https://github.com/udlbook/udlbook/raw/main/UDL_Equations.tex">
+                LaTeX 
+                </UDLLink>{" "}
+                for all equations 
+            </HeroNewsItemContent>
+        ),
+    },
+    {
+        date: "12/17/24",
+        content: (
+            <HeroNewsItemContent>
+                
+                <UDLLink href="https://www.youtube.com/playlist?list=PLRdABJkXXytCz19PsZ1PCQBKoZGV069k3">
+                    Video lectures
+                </UDLLink>{" "}
+                for chapters 1-12 from Tamer Elsayed of Qatar University.
+            </HeroNewsItemContent>
+        ),
+    },
+    {
+        date: "12/05/24",
+        content: (
+            <HeroNewsItemContent>
+                New{" "}
+                <UDLLink href="https://rbcborealis.com/research-blogs/neural-network-gaussian-processes/">
+                    blog
+                </UDLLink>{" "}
+                on Neural network Gaussian processes
+            </HeroNewsItemContent>
+        ),
+    },
+
+    {
+        date: "11/14/24",
+        content: (
+            <HeroNewsItemContent>
+                New{" "}
+                <UDLLink href=" https://rbcborealis.com/research-blogs/bayesian-neural-networks/">
+                    blog
+                </UDLLink>{" "}
+                on Bayesian Neural Networks
+            </HeroNewsItemContent>
+        ),
+    },
+    {
+        date: "08/13/24",
+        content: (
+            <HeroNewsItemContent>
+                New{" "}
+                <UDLLink href="https://www.borealisai.com/research-blogs/bayesian-machine-learning-function-space/">
+                    blog
+                </UDLLink>{" "}
+                on Bayesian machine learning (function perspective)
+            </HeroNewsItemContent>
+        ),
+    },
+    {
+        date: "08/05/24",
+        content: (
+            <HeroNewsItemContent>
+                Added{" "}
+                <UDLLink href="https://udlbook.github.io/udlfigures/">
+                    interactive figures
+                </UDLLink>{" "}
+                to explore 1D linear regression, shallow and deep networks, Gabor model.
+            </HeroNewsItemContent>
+        ),
+    },
+    {
+        date: "07/30/24",
+        content: (
+            <HeroNewsItemContent>
+                New{" "}
+                <UDLLink href="https://www.borealisai.com/research-blogs/bayesian-machine-learning-parameter-space/">
+                    blog
+                </UDLLink>{" "}
+                on Bayesian machine learning (parameter perspective)
+            </HeroNewsItemContent>
+        ),
+    },
     {
         date: "05/22/24",
         content: (
@@ -184,8 +302,8 @@ export default function HeroSection() {
                         <HeroImgWrap>
                             <Img src={img} alt="Book Cover" />
                         </HeroImgWrap>
-                        <HeroLink href="https://github.com/udlbook/udlbook/releases/download/v4.0.1/UnderstandingDeepLearning_05_27_24_C.pdf">
+                        <HeroLink href="https://github.com/udlbook/udlbook/releases/download/v5.0.2/UnderstandingDeepLearning_05_29_25_C.pdf">
-                            Download full PDF (27 May 2024)
+                            Download full PDF (29 May 2025)
                         </HeroLink>
                         <br /> 
                         <HeroDownloadsImg
@@ -201,7 +319,7 @@ export default function HeroSection() {
                         <HeroLink href="https://github.com/udlbook/udlbook/raw/main/UDL_Errata.pdf">
                             Errata
                         </HeroLink>
-                    </HeroColumn2>
+                    </HeroColumn2> <h1></h1>
                 </HeroRow> 
             </HeroContent>
         </HeroContainer>

src/components/Instructors/index.jsx

@@ -280,6 +280,12 @@ export default function InstructorsSection() {
                             </InstructorsLink>{" "}
                             with MIT Press for answer booklet.
                             <InstructorsContent></InstructorsContent>
+                            <TopLine>Interactive figures</TopLine>
+                            <InstructorsLink href="https://udlbook.github.io/udlfigures/">
+                            Interactive figures  </InstructorsLink>{" "} 
+                            to illustrate ideas in class
+                            <InstructorsContent></InstructorsContent>
+    
                             <TopLine>Full slides</TopLine>
                             <InstructorsContent>
                                 Slides for 20 lecture undergraduate deep learning course:
@@ -296,6 +302,11 @@ export default function InstructorsSection() {
                                     ))}
                                 </ol>
                             </InstructorsContent>
+                            <TopLine>LaTeX for equations</TopLine>
+                            A {" "} <InstructorsLink href="https://github.com/udlbook/udlbook/raw/main/UDL_Equations.tex">
+                            working Latex file  </InstructorsLink>{" "} 
+                            containing all of the equations
+                            <InstructorsContent></InstructorsContent>
                         </Column1>
                         <Column2>
                             <TopLine>Figures</TopLine>
@@ -325,6 +336,11 @@ export default function InstructorsSection() {
                             </InstructorsLink>{" "}
                             for editing equations in figures.
                             <InstructorsContent></InstructorsContent>
+                            <TopLine>LaTeX Bibfile </TopLine>
+                            The {" "} <InstructorsLink href="https://github.com/udlbook/udlbook/raw/main/understanding-deep-learning-final.bib">
+                            bibfile  </InstructorsLink>{" "} 
+                            containing all of the references
+                            <InstructorsContent></InstructorsContent>
                         </Column2>
                     </InstructorsRow2>
                 </InstructorsWrapper>

src/components/Media/index.jsx

@@ -69,22 +69,6 @@ export default function MediaSection() {
                             </VideoFrame>
                         </Column1>
                         <Column2>
-                            Deeper insights podcast
-                            <VideoFrame>
-                                <iframe
-                                    width="100%"
-                                    height="100%"
-                                    src="https://www.youtube.com/embed/nQf4o9TDSHI?si=uMk66zLD7uhuSnQ1&amp;controls=0"
-                                    title="YouTube video player"
-                                    frameBorder="2"
-                                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
-                                    allowfullscreen
-                                ></iframe>
-                            </VideoFrame>
-                        </Column2>
-                    </MediaRow>
-                    <MediaRow2>
-                        <Column1>
                         <TopLine>Reviews</TopLine>
                             <MediaContent>
                                 {/* TODO: add dynamic rendering for reviews */}
@@ -120,28 +104,21 @@ export default function MediaSection() {
                                         by Vishal V.
                                     </li>
                                     <li>
-                                        Amazon{" "}
+                                        Book{" "}
-                                        <MediaLink href="https://www.amazon.com/Understanding-Deep-Learning-Simon-Prince-ebook/product-reviews/B0BXKH8XY6/">
+                                        <MediaLink href="https://www.linkedin.com/pulse/review-understanding-deep-learning-prof-simon-prince-chandrasekharan-6egec/">
-                                            reviews
+                                            review
-                                        </MediaLink>
+                                        </MediaLink>{" "}
-                                    </li>
+                                        by Nidhin Chandrasekharan
-                                    <li>
-                                        Goodreads{" "}
-                                        <MediaLink href="https://www.goodreads.com/book/show/123239819-understanding-deep-learning?">
-                                            reviews{" "}
-                                        </MediaLink>
                                     </li>
                                     <li>
                                         Book{" "}
-                                        <MediaLink href="https://medium.com/@vishalvignesh/udl-book-review-the-new-deep-learning-textbook-youll-want-to-finish-69e1557b018d">
+                                        <MediaLink href="https://www.justinmath.com/the-best-neural-nets-textbook/">
                                             review
                                         </MediaLink>{" "}
-                                        by Vishal V.
+                                        by Justin Skycak
                                     </li>
                                 </ul>
                             </MediaContent>
-                        </Column1>
-                        <Column2>
                             <TopLine>Interviews</TopLine>
                             <MediaContent>
                                 <ul>
@@ -155,8 +132,17 @@ export default function MediaSection() {
                                     ))}
                                 </ul>
                             </MediaContent>
+                            <TopLine>Video lectures</TopLine>  
+                            <ul>    
+                                <li>            
+                                    <MediaLink href="https://www.youtube.com/playlist?list=PLRdABJkXXytCz19PsZ1PCQBKoZGV069k3">
+                                        Video lectures 
+                                    </MediaLink>{" "} for chapters 1-12 from Tamer Elsayed
+                                </li>  
+                            </ul>
+ 
                         </Column2>
-                    </MediaRow2>
+                    </MediaRow>
                 </MediaWrapper>
             </MediaContainer>
         </>

src/components/More/index.jsx

@@ -376,6 +376,51 @@ const aiTheory = [
             "NTK and generalizability",
         ],
     },
+    {
+        text: "Bayesian ML I",
+        link: "https://www.borealisai.com/research-blogs/bayesian-machine-learning-parameter-space/",
+        details: [
+            "Maximum likelihood",
+            "Maximum a posteriori",
+            "The Bayesian approach",
+            "Example: 1D linear regression",
+            "Practical concerns",
+        ],
+    },
+    {
+        text: "Bayesian ML II",
+        link: "https://www.borealisai.com/research-blogs/bayesian-machine-learning-function-space/",
+        details: [
+            "Function space",
+            "Gaussian processes",
+            "Inference",
+            "Non-linear regression",
+            "Kernels and the kernel trick",
+        ],
+    },
+    {
+        text: "Bayesian neural networks",
+        link: "https://rbcborealis.com/research-blogs/bayesian-neural-networks/",
+        details: [
+            "Sampling vs. variational approximation",
+            "MCMC methods",
+            "SWAG and MultiSWAG",
+            "Bayes by backprop",
+            "Monte Carlo dropout",
+        ],
+    },
+    {
+        text: "Neural network Gaussian processes",
+        link: "https://rbcborealis.com/research-blogs/neural-network-gaussian-processes/",
+        details: [
+            "Shallow networks as GPs",
+            "Neural network Gaussian processes",
+            "NNGP Kernel",
+            "Kernel regression",
+            "Network stability",
+        ],
+    },
+    
 ];
 
 const unsupervisedLearning = [
@@ -664,6 +709,50 @@ const responsibleAI = [
     },
 ];
 
+const ODESDE = [
+    {
+        text: "ODEs and SDEs in machine learning",
+        link: "https://rbcborealis.com/research-blogs/odes-and-sdes-for-machine-learning/",
+        details: [
+            "ODEs",
+            "SDEs",
+            "ODEs and gradient descent",
+            "SDEs in stochastic gradient descent",
+            "ODEs in residual networks",
+            "ODEs and SDES in diffusion models",
+            "Physics-informed machine learning",
+        ],
+    },
+    {
+        text: "Introduction to ODEs",
+        link: "https://rbcborealis.com/research-blogs/introduction-ordinary-differential-equations/",
+        details: [
+            "What are ODEs?",
+            "Terminology and properties",
+            "Solutions",
+            "Boundary conditions",
+            "Existence of solutions",
+        ],
+    },
+    {
+        text: "Closed-form solutions for ODEs",
+        link: "https://rbcborealis.com/research-blogs/closed-form-solutions-for-odes/",
+        details: [
+            "Validating proposed solutions",
+            "Class 1: Right-hand side is a function of t only",
+            "Class 2: Linear homogeneous",
+            "Class 3: right-hand side is function of x alone",
+            "Class 4: Right-hand side is a separable function of x and t",
+            "Class 5: Exact ODEs",
+            "Class 6: linear inhomogeneous ODEs",
+            "Class 7: Euler homogeneous",
+            "Vector ODEs",
+            "The matrix exponential"
+        ],
+    },
+]
+
+
 export default function MoreSection() {
     return (
         <>
@@ -689,7 +778,7 @@ export default function MoreSection() {
                     </MoreRow>
                     <MoreRow2>
                         <Column1>
-                            <TopLine>Book</TopLine>
+                            <TopLine>Computer vision book</TopLine>
                             <MoreOuterList>
                                 {book.map((item, index) => (
                                     <li key={index}>
@@ -814,10 +903,27 @@ export default function MoreSection() {
                                     </li>
                                 ))}
                             </MoreOuterList>
+                            <TopLine>ODEs and SDEs in machine learning</TopLine>
+                            <MoreOuterList>
+                                {ODESDE.map((item, index) => (
+                                    <li key={index}>
+                                        <MoreLink href={item.link} target="_blank" rel="noreferrer">
+                                            {item.text}
+                                        </MoreLink>
+                                        <MoreInnerP>
+                                            <MoreInnerList>
+                                                {item.details.map((detail, index) => (
+                                                    <li key={index}>{detail}</li>
+                                                ))}
+                                            </MoreInnerList>
+                                        </MoreInnerP>
+                                    </li>
+                                ))}
+                            </MoreOuterList>
                         </Column1>
 
                         <Column2>
-                            <TopLine>AI Theory</TopLine>
+                            <TopLine>ML Theory</TopLine>
                             <MoreOuterList>
                                 {aiTheory.map((item, index) => (
                                     <li key={index}>