cnn_gibbs_mnist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BhY4KEGub6-U"
      },
      "outputs": [],
      "source": [
        "import gibbs_mcmc_nn as mc #imports the file with all the functions of the Gibbs sampler\n",
        "import torch\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)\n",
        "torch.set_default_tensor_type(torch.FloatTensor) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xlbsc6-eFR9K",
        "outputId": "c3886aae-fa8f-4f22-a73c-1818fe05e6a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction\n",
        "In this notebook we will use the Gibbs sampler to sampel form the posterior of a neural network, in the case where the training set is MNIST.\n",
        "\n",
        "\n",
        "\n",
        "The algorithm is described in detail in the paper **Gibbs Sampling the Posterior of Neural Networks**.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "japQqCpGcUZk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Architecture & Posterior\n",
        "\n",
        "We list the layers of the CNN together with their parameters.\n",
        "The input in a tensor of shape $n\\times 1\\times28\\times 28$, with $n$ the size of the training set. \n",
        "1. Convolutional layer with $4\\times 4$ filter, 2 output channels, stride=2, no padding. Output: `Z`\n",
        "2. Average $2\\times 2$ pooling with stride=2. Output: `Z_2`\n",
        "3. ReLU activation. Output `X_2`\n",
        "4. Fully connected layer with $10\\times 72$ weights. Output: `Z_3`\n",
        "5. Argmax activation over the 10 output units. Outputs the labels\n",
        "\n",
        "\n",
        "\n",
        "Now we must associate a posterior to this architecture. \n",
        "We do so by specifying the implicit generative process.\n",
        "We assume that after each layer above  except for the argmax a Gaussian noise with variance $\\Delta$ is added. The prior is i.i.d. Gaussian with inverse variances on each weight $\\lambda_W^{(1)}=16,\\lambda_b^{(1)}=16,\\lambda_{W}^{(2)}=72,\\lambda_{b}^{(2)}=72$."
      ],
      "metadata": {
        "id": "jryOh3UGc_wB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def CNN_net(X,W,b,s_y,s_x,H_P,W_P,W_2,b_2): \n",
        "    \"\"\"\n",
        "    Computes the output of the CNN network on a batch of data\n",
        "\n",
        "    X is the input tensor\n",
        "    W are the weights of the convolutional layer\n",
        "    b is the bias vector associated to the convolutional layer\n",
        "    s_y,s_x are the strides of the convolutional layer\n",
        "    H_P, W_P are the height and width of the pooling filters\n",
        "    W_2,b_2 are the weights and biases of the fully connected layer\n",
        "    \"\"\"\n",
        "    \n",
        "    Z=mc.conv2d_layer(X,W,s_y,s_x)+b[None,:,None,None]\n",
        "    Z_2=mc.average_pool2d(Z,H_P,W_P)\n",
        "    X_2=mc.ReLU(Z_2).reshape([Z_2.shape[0],-1])\n",
        "    Z_3=X_2@(W_2.T)+b_2[None,:]\n",
        "    return torch.argmax(Z_3,axis=1).type(torch.long)"
      ],
      "metadata": {
        "id": "-bXB93JwtP-g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dataset loading\n",
        "We load the MNIST dataset from the file `mnist.npz` downloadable at https://www.kaggle.com/datasets/vikramtiwari/mnist-numpy .\n"
      ],
      "metadata": {
        "id": "hiRjeGUcyOWj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n=2000 #number of training points\n",
        "n_test=5000 #number of test points\n",
        "file_mnist=np.load(\"./mnist.npz\",allow_pickle=True)\n",
        "X_train=torch.tensor(file_mnist['x_train'],dtype=torch.float)[:n,None,:,:]\n",
        "X_test=torch.tensor(file_mnist['x_test'],dtype=torch.float)[:n_test,None,:,:]\n",
        "y_train=torch.tensor(file_mnist['y_train']).type(torch.long).flatten()[:n]\n",
        "y_test=torch.tensor(file_mnist['y_test']).type(torch.long).flatten()[:n_test]\n",
        "\n",
        "\n",
        "#normalizing training and test inputs\n",
        "X_train=X_train[:n]/255\n",
        "X_test=X_test[:n_test]/255\n",
        "mean_X=torch.mean(X_train)\n",
        "std_X=torch.std(X_train)\n",
        "X_train=(X_train-mean_X)/std_X\n",
        "X_test=(X_test-mean_X)/std_X"
      ],
      "metadata": {
        "id": "q7EOKh76cK8q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Gibbs parameters\n",
        "\n",
        "We will now run the Gibbs sampler on the dataset. \n",
        "First we must set the algorithm's parameters, i.e., $\\Delta,\\lambda_W^{(1)},\\lambda_W^{(1)},\\lambda_W^{(2)}, \\lambda_b^{(2)}$. "
      ],
      "metadata": {
        "id": "y_x4MbJP8wzF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sigma=torch.nn.ReLU()\n",
        "C_X=1 #number of input channels (1 for MNIST)\n",
        "H_X=28 #input height\n",
        "W_X=28 #input width\n",
        "H_W=4 #convolutional filter's height\n",
        "W_W=4 #convolutional filter's height\n",
        "C_Z=2 #number of output channels of the convolutional layer\n",
        "s_y=2 #vertical stride of convolutional layer\n",
        "s_x=1 #horizontal stride of convolutional layer\n",
        "H_P=2 #height of the pooling filter\n",
        "W_P=2 #width of the pooling filter\n",
        "C=10 #number of classes\n",
        "H_Z=torch.div((H_X-H_W),s_y,rounding_mode='floor')+1 \n",
        "W_Z=torch.div((W_X-W_W),s_x,rounding_mode='floor')+1\n",
        "H_Z_2=torch.div(H_Z,H_P,rounding_mode='floor')\n",
        "W_Z_2=torch.div(W_Z,W_P,rounding_mode='floor')\n",
        "d_X_2=torch.tensor(C_Z*H_Z_2*W_Z_2)\n",
        "lambda_W=torch.tensor(H_W*W_W*C_X) #16\n",
        "lambda_b=torch.tensor(H_W*W_W*C_X) #16\n",
        "lambda_W_2=torch.tensor(d_X_2) #72\n",
        "lambda_b_2=d_X_2 #72\n",
        "Delta=torch.tensor(20) #temperature of the posterior"
      ],
      "metadata": {
        "id": "CC2bzlhc8z78",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "599a027e-f1ec-47a5-cf5f-5c5ab4e1b23e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-5-b0086992f58e>:17: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  d_X_2=torch.tensor(C_Z*H_Z_2*W_Z_2)\n",
            "<ipython-input-5-b0086992f58e>:20: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  lambda_W_2=torch.tensor(d_X_2) #72\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Initialization\n",
        "for the Gibbs sampler we set all variables initially to zero.\n"
      ],
      "metadata": {
        "id": "UjxmJetw_mg5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#zero initialization\n",
        "W=torch.zeros(size=[C_Z,C_X,H_W,W_W])\n",
        "b=torch.zeros(size=[C_Z])\n",
        "Z=torch.zeros(size=[n,C_Z,H_Z,W_Z])\n",
        "Z_2=torch.zeros(size=[n,C_Z,H_Z//2,W_Z//2])\n",
        "X_2=torch.zeros(size=[n,d_X_2])\n",
        "W_2=torch.zeros(size=[C,d_X_2])\n",
        "b_2=torch.zeros(size=[C])\n",
        "Z_3=torch.zeros(size=[n,C])"
      ],
      "metadata": {
        "id": "rueTjOGIFeSM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#precomute quantities for sampling the first layer's weights\n",
        "#precomputed quantities\n",
        "jump_y,jump_x=X_train.stride()[-2:] #number of positions I have to move in memory to go to the next  3rd, 4th index respectively in X_l.\n",
        "X_strided_shape=(n,C_X,H_W,W_W,H_Z,W_Z) \n",
        "X_strides=X_train.stride()+(s_y*jump_y,s_x*jump_x)\n",
        "\n",
        "X_strided=torch.as_strided(X_train.type(torch.float64),size=X_strided_shape, stride=X_strides)\n",
        "A_tilde_resc=torch.tensordot(X_strided,X_strided, [[0,4,5],[0,4,5]])\n",
        "\n",
        "A_resc=A_tilde_resc.reshape([C_X*H_W*W_W,C_X*H_W*W_W]) \n",
        "A_resc=A_resc+lambda_W*Delta*torch.eye(C_X*H_W*W_W,dtype=torch.float64)\n",
        "Cov_W_resc=torch.linalg.inv(A_resc)  \n",
        "Cholesky_Cov_W_resc=torch.linalg.cholesky(Cov_W_resc).type(torch.float32)  #<---should be passed as argument\n",
        "Cov_W_resc_XT=torch.tensordot(Cov_W_resc.reshape([C_X*H_W*W_W,C_X,H_W,W_W]),X_strided,[[1,2,3],[1,2,3]]).type(torch.float32) #<--- should be passed as argument"
      ],
      "metadata": {
        "id": "ec-Gijjad-UP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#moving the variables to the GPU (if needed)\n",
        "Delta=Delta.to(device)\n",
        "lambda_W=lambda_W.to(device)\n",
        "lambda_b=lambda_b.to(device)\n",
        "lambda_W_2=lambda_W_2.to(device)\n",
        "lambda_b_2=lambda_b_2.to(device)\n",
        "W=W.to(device)\n",
        "b=b.to(device)\n",
        "Z=Z.to(device)\n",
        "Z_2=Z_2.to(device)\n",
        "X_2=X_2.to(device)\n",
        "W_2=W_2.to(device)\n",
        "b_2=b_2.to(device)\n",
        "Z_3=Z_3.to(device)\n",
        "X_train=X_train.to(device)\n",
        "y_train=y_train.to(device)\n",
        "X_test=X_test.to(device)\n",
        "y_test=y_test.to(device)\n",
        "Cholesky_Cov_W_resc=Cholesky_Cov_W_resc.to(device)\n",
        "Cov_W_resc_XT=Cov_W_resc_XT.to(device)\n",
        "if(str(device)=='cuda'):\n",
        "    torch.set_default_tensor_type(torch.cuda.FloatTensor) "
      ],
      "metadata": {
        "id": "I6R5KsEVHkUc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#stuff to track during the dynamics\n",
        "test_loss=[]\n",
        "train_loss=[]\n",
        "W_1_norm=[]\n",
        "W_2_norm=[]\n",
        "tmax=5000"
      ],
      "metadata": {
        "id": "2cuO3qjdF1UH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Run the Gibbs sampler"
      ],
      "metadata": {
        "id": "da1zzPvxJrgo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for t in range(tmax):\n",
        "    y_pred_test=CNN_net(X_test,W,b,s_y,s_x,H_P,W_P,W_2,b_2)\n",
        "    y_pred_train=CNN_net(X_train,W,b,s_y,s_x,H_P,W_P,W_2,b_2)\n",
        "    test_loss.append(1.-torch.sum(y_pred_test==y_test).item()/(y_test.shape[0]))\n",
        "    train_loss.append(1.-torch.sum(y_pred_train==y_train).item()/(y_train.shape[0]))\n",
        "\n",
        "    #updating the variables (in this case in reverse order)\n",
        "    Z_3=mc.sample_Z_Lp1_multinomial_probit(X_2@(W_2.T)+b_2[None,:],Z_3,y_train,Delta_Z_Lp1=Delta,precise=True)\n",
        "    W_2=mc.sample_W_l_fcl(X_2,b_2,Z_3,lambda_W_2,Delta_Z_lp1=Delta)\n",
        "    b_2=mc.sample_b_l_fcl(W_2,Z_3,X_2,Delta_Z_lp1=Delta,lambda_b_l=lambda_b_2)\n",
        "    X_2=mc.sample_X_l_fcl(mc.ReLU(Z_2).reshape([n,-1]),W_2,b_2,Z_3,Delta_X_l=Delta,Delta_Z_lp1=Delta)\n",
        "    Z_2=mc.sample_Z_lp1_relu(fwd_X_l=mc.average_pool2d(Z,H_P,W_P),X_lp1=X_2.reshape([n,C_Z,H_Z_2,W_Z_2]),Delta_Z_lp1=Delta,Delta_X_lp1=Delta,precise=True)    \n",
        "    Z=mc.sample_X_l_avg_pooling(fwd_Z_l=mc.conv2d_layer(X_train,W,s_y,s_x)+b[None,:,None,None],X_lp1=Z_2,Delta_X_l=Delta, Delta_X_lp1=Delta)\n",
        "    W=mc.sample_W_1_conv2d(Cholesky_Cov_W_resc, Cov_W_resc_XT,b,Z,Delta_Z_2=Delta, H_W=H_W, W_W=W_W, C_1=C_X)\n",
        "    b=mc.sample_b_l_conv2d(X_train,Z,W,Delta_Z_lp1=Delta,lambda_b_l=lambda_b,stride_y=s_y,stride_x=s_x)"
      ],
      "metadata": {
        "id": "hQs0OcBv_Xst"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(test_loss,label=\"test error\")\n",
        "plt.plot(train_loss,label=\"train error\")\n",
        "plt.xlabel(\"t (steps)\")\n",
        "plt.ylabel(\"error (1 - accuracy)\")\n",
        "plt.xscale('log')\n",
        "plt.yscale('log')\n",
        "plt.grid()\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 477
        },
        "id": "Xk2if7miK8m0",
        "outputId": "44a97e5c-63f6-4782-e193-f23fd1538711"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fb79ba4d8d0>"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GpIe8QPuJIt-"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}