minimal_example_of_mlpinit.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/snap-research/MLPInit-for-GNNs/blob/main/minimal_example_of_mlpinit.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip uninstall -y torch\n",
    "! pip uninstall -y torchvision torchtext torchdata torchaudio fastai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install torch==1.9.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html\n",
    "! pip install https://data.pyg.org/whl/torch-1.9.0%2Bcu111/torch_scatter-2.0.9-cp39-cp39-linux_x86_64.whl\n",
    "! pip install https://data.pyg.org/whl/torch-1.9.0%2Bcu111/torch_sparse-0.6.12-cp39-cp39-linux_x86_64.whl\n",
    "! pip install torch-geometric==2.0.4\n",
    "! pip install ogb==1.3.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:The OGB package is out of date. Your version is 1.3.3, while the latest version is 1.3.5.\n",
      "/data/han/miniconda3/envs/torch190_geo204/lib/python3.7/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os.path as osp\n",
    "from ogb.nodeproppred import Evaluator, PygNodePropPredDataset\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from torch_geometric.loader import NeighborSampler\n",
    "from torch_geometric.nn import SAGEConv\n",
    "from torch.nn import Linear\n",
    "from typing import Tuple, Union\n",
    "\n",
    "import torch.nn.functional as F\n",
    "from torch import Tensor\n",
    "from torch_geometric.nn.dense.linear import Linear\n",
    "from torch_geometric.typing import Adj, OptPairTensor, Size\n",
    "import torch.utils.data as data_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data.x.shape: torch.Size([2449029, 100])\n",
      "data.y.shape: torch.Size([2449029, 1])\n",
      "data.x.type: torch.float32\n",
      "data.y.type: torch.int64\n",
      "X_train.shape: torch.Size([196615, 100])\n",
      "y_train.shape: torch.Size([196615])\n",
      "data.y.type: torch.int64\n"
     ]
    }
   ],
   "source": [
    "dataset_name = \"ogbn-products\"\n",
    "dataset_dir = \"./data\"\n",
    "\n",
    "# \n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "root = osp.join( dataset_dir, dataset_name)\n",
    "\n",
    "dataset = PygNodePropPredDataset(dataset_name, root)\n",
    "split_idx = dataset.get_idx_split()\n",
    "evaluator = Evaluator(name=dataset_name)\n",
    "data = dataset[0]\n",
    "train_idx = split_idx['train']\n",
    "\n",
    "X_train = data.x[ split_idx[\"train\"] ]\n",
    "y_train = data.y[ split_idx[\"train\"] ].reshape(-1).type(torch.long)\n",
    "\n",
    "\n",
    "x = data.x\n",
    "y = data.y.squeeze()\n",
    "\n",
    "\n",
    "\n",
    "print( \"data.x.shape:\", data.x.shape )\n",
    "print( \"data.y.shape:\", data.y.shape )\n",
    "print( \"data.x.type:\", x.dtype )\n",
    "print( \"data.y.type:\", y.dtype )\n",
    "print( \"X_train.shape:\", X_train.shape )\n",
    "print( \"y_train.shape:\", y_train.shape )\n",
    "\n",
    "\n",
    "y = data.y.squeeze().type(torch.long)\n",
    "print( \"data.y.type:\", y.dtype )\n",
    "\n",
    "\n",
    "X_y_train_mlpinit = data_utils.TensorDataset(X_train, y_train)\n",
    "X_y_all_mlpinit = data_utils.TensorDataset(x, y)\n",
    "\n",
    "train_mlpinit_loader = data_utils.DataLoader(X_y_train_mlpinit, batch_size=4096, shuffle=True, num_workers=4)\n",
    "all_mlpinit_loader = data_utils.DataLoader(X_y_all_mlpinit, batch_size=4096, shuffle=False, num_workers=4)\n",
    "\n",
    "\n",
    "class SAGEConv_like_MLP(torch.nn.Module):\n",
    "   \n",
    "    def __init__(self, in_channels: Union[int, Tuple[int, int]],\n",
    "                 out_channels: int, normalize: bool = False,\n",
    "                 root_weight: bool = True, bias: bool = True, **kwargs):\n",
    "        # kwargs.setdefault('aggr', 'mean')\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "        self.in_channels = in_channels\n",
    "        self.out_channels = out_channels\n",
    "        self.normalize = normalize\n",
    "        self.root_weight = root_weight\n",
    "\n",
    "        if isinstance(in_channels, int):\n",
    "            in_channels = (in_channels, in_channels)\n",
    "\n",
    "        self.lin_l = Linear(in_channels[0], out_channels, bias=bias)\n",
    "        if self.root_weight:\n",
    "            self.lin_r = Linear(in_channels[1], out_channels, bias=False)\n",
    "\n",
    "        self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        self.lin_l.reset_parameters()\n",
    "        if self.root_weight:\n",
    "            self.lin_r.reset_parameters()\n",
    "\n",
    "\n",
    "    def forward(self, x: Union[Tensor, OptPairTensor]) -> Tensor:\n",
    "        \"\"\"\"\"\"\n",
    "        if isinstance(x, Tensor):\n",
    "            x: OptPairTensor = (x, x)\n",
    "\n",
    "        out = x[1]\n",
    "        out = self.lin_l(out)\n",
    "\n",
    "        x_r = x[1]\n",
    "        if self.root_weight and x_r is not None:\n",
    "            out += self.lin_r(x_r)\n",
    "\n",
    "        if self.normalize:\n",
    "            out = F.normalize(out, p=2., dim=-1)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "\n",
    "class MLP(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels, num_layers):\n",
    "        super().__init__()\n",
    "\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        self.convs = torch.nn.ModuleList()\n",
    "        self.convs.append(SAGEConv_like_MLP(in_channels, hidden_channels))\n",
    "        for _ in range(num_layers - 2):\n",
    "            self.convs.append(SAGEConv_like_MLP(hidden_channels, hidden_channels))\n",
    "        self.convs.append(SAGEConv_like_MLP(hidden_channels, out_channels))\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        for conv in self.convs:\n",
    "            conv.reset_parameters()\n",
    "\n",
    "    def forward(self, x):\n",
    "        for i in range(self.num_layers):\n",
    "            x_target = x\n",
    "            x = self.convs[i]((x, x_target))\n",
    "            if i != self.num_layers - 1:\n",
    "                x = F.relu(x)\n",
    "                x = F.dropout(x, p=0.5, training=self.training)\n",
    "        return x.log_softmax(dim=-1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "class SAGE(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels, num_layers):\n",
    "        super().__init__()\n",
    "\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        self.convs = torch.nn.ModuleList()\n",
    "        self.convs.append(SAGEConv(in_channels, hidden_channels))\n",
    "        for _ in range(num_layers - 2):\n",
    "            self.convs.append(SAGEConv(hidden_channels, hidden_channels))\n",
    "        self.convs.append(SAGEConv(hidden_channels, out_channels))\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        for conv in self.convs:\n",
    "            conv.reset_parameters()\n",
    "\n",
    "    def forward(self, x, adjs):\n",
    "        # `train_loader` computes the k-hop neighborhood of a batch of nodes,\n",
    "        # and returns, for each layer, a bipartite graph object, holding the\n",
    "        # bipartite edges `edge_index`, the index `e_id` of the original edges,\n",
    "        # and the size/shape `size` of the bipartite graph.\n",
    "        # Target nodes are also included in the source nodes so that one can\n",
    "        # easily apply skip-connections or add self-loops.\n",
    "        for i, (edge_index, _, size) in enumerate(adjs):\n",
    "            x_target = x[:size[1]]  # Target nodes are always placed first.\n",
    "            x = self.convs[i]((x, x_target), edge_index)\n",
    "            if i != self.num_layers - 1:\n",
    "                x = F.relu(x)\n",
    "                x = F.dropout(x, p=0.5, training=self.training)\n",
    "        return x.log_softmax(dim=-1)\n",
    "\n",
    "\n",
    "\n",
    "    def inference(self, x_all):\n",
    "        pbar = tqdm(total=x_all.size(0) * self.num_layers)\n",
    "        pbar.set_description('Evaluating')\n",
    "\n",
    "        # Compute representations of nodes layer by layer, using *all*\n",
    "        # available edges. This leads to faster computation in contrast to\n",
    "        # immediately computing the final representations of each batch.\n",
    "        total_edges = 0\n",
    "        for i in range(self.num_layers):\n",
    "            xs = []\n",
    "            for batch_size, n_id, adj in subgraph_loader:\n",
    "                edge_index, _, size = adj.to(device)\n",
    "                total_edges += edge_index.size(1)\n",
    "                x = x_all[n_id].to(device)\n",
    "                x_target = x[:size[1]]\n",
    "                x = self.convs[i]((x, x_target), edge_index)\n",
    "                if i != self.num_layers - 1:\n",
    "                    x = F.relu(x)\n",
    "                xs.append(x.cpu())\n",
    "\n",
    "                pbar.update(batch_size)\n",
    "\n",
    "            x_all = torch.cat(xs, dim=0)\n",
    "\n",
    "        pbar.close()\n",
    "\n",
    "        return x_all\n",
    "\n",
    "\n",
    "\n",
    "model_mlpinit = MLP(dataset.num_features, 512, dataset.num_classes, num_layers=4)\n",
    "model_mlpinit = model_mlpinit.to(device)\n",
    "optimizer_model_mlpinit = torch.optim.Adam(model_mlpinit.parameters(), lr=0.001, weight_decay = 0.0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_mlpinit():\n",
    "    model_mlpinit.train()\n",
    "    total_loss = total_correct = 0\n",
    "\n",
    "    for x, y in train_mlpinit_loader:\n",
    "\n",
    "        x = x.to( device )\n",
    "        y = y.to( device )\n",
    "\n",
    "        optimizer_model_mlpinit.zero_grad()\n",
    "        out = model_mlpinit(x)\n",
    "        loss = F.nll_loss(out, y)\n",
    "        loss.backward()\n",
    "        optimizer_model_mlpinit.step()\n",
    "\n",
    "        total_loss += float(loss)\n",
    "\n",
    "    loss = total_loss / len(train_mlpinit_loader)\n",
    "    approx_acc = total_correct / train_idx.size(0)\n",
    "\n",
    "    return loss, approx_acc\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def test_mlpinit():\n",
    "    model_mlpinit.eval()\n",
    "\n",
    "    out_list = []\n",
    "    y_list = []\n",
    "\n",
    "    for x, y in  all_mlpinit_loader:\n",
    "        x = x.to( device )\n",
    "        y = y.to( device )\n",
    "        out = model_mlpinit(x)\n",
    "        out_list.append( out )\n",
    "        y_list.append( y )\n",
    "\n",
    "\n",
    "    out = torch.cat(out_list, dim=0)\n",
    "    y_true = torch.cat(y_list, dim=0).cpu().unsqueeze(-1)\n",
    "\n",
    "\n",
    "    y_pred = out.argmax(dim=-1, keepdim=True)\n",
    "\n",
    "    train_acc = evaluator.eval({\n",
    "        'y_true': y_true[split_idx['train']],\n",
    "        'y_pred': y_pred[split_idx['train']],\n",
    "    })['acc']\n",
    "    val_acc = evaluator.eval({\n",
    "        'y_true': y_true[split_idx['valid']],\n",
    "        'y_pred': y_pred[split_idx['valid']],\n",
    "    })['acc']\n",
    "    test_acc = evaluator.eval({\n",
    "        'y_true': y_true[split_idx['test']],\n",
    "        'y_pred': y_pred[split_idx['test']],\n",
    "    })['acc']\n",
    "\n",
    "    return train_acc, val_acc, test_acc\n",
    "\n",
    "\n",
    "\n",
    "train_loader = NeighborSampler(data.edge_index, node_idx=train_idx,\n",
    "                               sizes=[25, 10, 5, 5], batch_size=1024,\n",
    "                               shuffle=True, num_workers=12)\n",
    "subgraph_loader = NeighborSampler(data.edge_index, node_idx=None, sizes=[-1],\n",
    "                                  batch_size=4096, shuffle=False,\n",
    "                                  num_workers=12)\n",
    "\n",
    "\n",
    "model = SAGE(dataset.num_features, 512, dataset.num_classes, num_layers=4)\n",
    "model = model.to(device)\n",
    "\n",
    "\n",
    "\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "\n",
    "    pbar = tqdm(total=train_idx.size(0))\n",
    "    pbar.set_description(f'Epoch {epoch:02d}')\n",
    "\n",
    "    total_loss = total_correct = 0\n",
    "\n",
    "    for batch_size, n_id, adjs in train_loader:\n",
    "        # `adjs` holds a list of `(edge_index, e_id, size)` tuples.\n",
    "        adjs = [adj.to(device) for adj in adjs]\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        out = model(x[n_id].to(device), adjs)\n",
    "        loss = F.nll_loss( out, y[n_id[:batch_size]].to(device) )\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        total_loss += float(loss)\n",
    "        total_correct += int(out.argmax(dim=-1).eq( y[n_id[:batch_size]].to(device) ).sum())\n",
    "        pbar.update(batch_size)\n",
    "\n",
    "    pbar.close()\n",
    "\n",
    "    loss = total_loss / len(train_loader)\n",
    "    approx_acc = total_correct / train_idx.size(0)\n",
    "\n",
    "    return loss, approx_acc\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def test():\n",
    "    model.eval()\n",
    "\n",
    "    out = model.inference(x)\n",
    "\n",
    "    y_true = y.cpu().unsqueeze(-1)\n",
    "    y_pred = out.argmax(dim=-1, keepdim=True)\n",
    "\n",
    "    train_acc = evaluator.eval({\n",
    "        'y_true': y_true[split_idx['train']],\n",
    "        'y_pred': y_pred[split_idx['train']],\n",
    "    })['acc']\n",
    "    val_acc = evaluator.eval({\n",
    "        'y_true': y_true[split_idx['valid']],\n",
    "        'y_pred': y_pred[split_idx['valid']],\n",
    "    })['acc']\n",
    "    test_acc = evaluator.eval({\n",
    "        'y_true': y_true[split_idx['test']],\n",
    "        'y_pred': y_pred[split_idx['test']],\n",
    "    })['acc']\n",
    "\n",
    "    return train_acc, val_acc, test_acc\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 01: 100%|██████████| 196615/196615 [01:33<00:00, 2105.53it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:53<00:00, 56523.84it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 01, Train: 0.8784, Val: 0.8723, Test: 0.7087\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 02: 100%|██████████| 196615/196615 [01:32<00:00, 2122.68it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:59<00:00, 54590.62it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 02, Train: 0.8974, Val: 0.8933, Test: 0.7504\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 03: 100%|██████████| 196615/196615 [01:23<00:00, 2357.99it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:52<00:00, 56726.35it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 03, Train: 0.9155, Val: 0.9066, Test: 0.7638\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 04: 100%|██████████| 196615/196615 [01:26<00:00, 2282.36it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:57<00:00, 55282.10it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 04, Train: 0.9118, Val: 0.9056, Test: 0.7777\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 05: 100%|██████████| 196615/196615 [01:24<00:00, 2324.60it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:48<00:00, 58130.96it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 05, Train: 0.9244, Val: 0.9148, Test: 0.7963\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 06: 100%|██████████| 196615/196615 [01:21<00:00, 2417.86it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:59<00:00, 54566.47it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 06, Train: 0.9171, Val: 0.9066, Test: 0.7869\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 07: 100%|██████████| 196615/196615 [01:24<00:00, 2324.60it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:52<00:00, 56882.42it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 07, Train: 0.9196, Val: 0.9104, Test: 0.7766\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 08: 100%|██████████| 196615/196615 [01:25<00:00, 2294.51it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:56<00:00, 55524.60it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 08, Train: 0.9242, Val: 0.9116, Test: 0.7891\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 09: 100%|██████████| 196615/196615 [01:28<00:00, 2212.64it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:05<00:00, 52761.20it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 09, Train: 0.9292, Val: 0.9191, Test: 0.7985\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 196615/196615 [01:32<00:00, 2126.47it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:00<00:00, 54274.18it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10, Train: 0.9285, Val: 0.9138, Test: 0.8026\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 196615/196615 [01:21<00:00, 2416.86it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:01<00:00, 54092.61it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11, Train: 0.9250, Val: 0.9105, Test: 0.7963\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 196615/196615 [01:28<00:00, 2223.56it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:56<00:00, 55489.05it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12, Train: 0.9344, Val: 0.9170, Test: 0.7900\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 196615/196615 [01:21<00:00, 2413.88it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:58<00:00, 55011.76it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13, Train: 0.9380, Val: 0.9236, Test: 0.8037\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 196615/196615 [01:24<00:00, 2324.59it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:17<00:00, 49701.86it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14, Train: 0.9397, Val: 0.9239, Test: 0.8042\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 196615/196615 [01:27<00:00, 2249.69it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:10<00:00, 51496.22it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15, Train: 0.9284, Val: 0.9134, Test: 0.7953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 196615/196615 [01:23<00:00, 2351.22it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:56<00:00, 55655.17it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16, Train: 0.9415, Val: 0.9228, Test: 0.8065\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 196615/196615 [01:28<00:00, 2217.58it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:16<00:00, 49972.95it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17, Train: 0.9344, Val: 0.9180, Test: 0.7988\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 196615/196615 [01:27<00:00, 2250.13it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:05<00:00, 52801.84it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18, Train: 0.9414, Val: 0.9236, Test: 0.8124\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 196615/196615 [01:26<00:00, 2268.94it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:07<00:00, 52278.33it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19, Train: 0.9434, Val: 0.9257, Test: 0.8062\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 196615/196615 [01:25<00:00, 2306.42it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:22<00:00, 48440.16it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20, Train: 0.9172, Val: 0.8946, Test: 0.7768\n"
     ]
    }
   ],
   "source": [
    "random_losses = []\n",
    "random_test_accs = []\n",
    "\n",
    "model.reset_parameters()\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay = 0.0)\n",
    "\n",
    "best_val_acc = final_test_acc = 0\n",
    "for epoch in range(1, 21):\n",
    "    loss, acc = train(epoch)\n",
    "    train_acc, val_acc, test_acc = test()\n",
    "    print(f'Epoch {epoch:02d}, Train: {train_acc:.4f}, Val: {val_acc:.4f}, 'f'Test: {test_acc:.4f}')\n",
    "    \n",
    "    random_losses.append(loss)\n",
    "    random_test_accs.append(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_acc_init, val_acc_init, test_acc_init: 0.7768684993515246 0.7464079546321492 0.6032065558985148\n"
     ]
    }
   ],
   "source": [
    "model_mlpinit.reset_parameters()\n",
    "\n",
    "for epoch in range(1, 20):\n",
    "    loss, acc = train_mlpinit()\n",
    "    \n",
    "torch.save(model_mlpinit.state_dict(), f'./model_mlpinit.pt' )\n",
    "train_acc_init, val_acc_init, test_acc_init = test_mlpinit()\n",
    "print(  \"train_acc_init, val_acc_init, test_acc_init:\", train_acc_init, val_acc_init, test_acc_init )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 01: 100%|██████████| 196615/196615 [01:26<00:00, 2265.49it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:59<00:00, 54631.37it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 01, Train: 0.9170, Val: 0.9075, Test: 0.7771\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 02: 100%|██████████| 196615/196615 [01:22<00:00, 2385.20it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:03<00:00, 53421.86it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 02, Train: 0.9240, Val: 0.9122, Test: 0.7858\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 03: 100%|██████████| 196615/196615 [01:25<00:00, 2290.63it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:53<00:00, 56556.11it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 03, Train: 0.9303, Val: 0.9173, Test: 0.7967\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 04: 100%|██████████| 196615/196615 [01:25<00:00, 2303.70it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:59<00:00, 54456.88it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 04, Train: 0.9328, Val: 0.9187, Test: 0.7993\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 05: 100%|██████████| 196615/196615 [01:29<00:00, 2192.36it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:52<00:00, 56741.49it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 05, Train: 0.9316, Val: 0.9187, Test: 0.7950\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 06: 100%|██████████| 196615/196615 [01:22<00:00, 2397.23it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:57<00:00, 55261.36it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 06, Train: 0.9342, Val: 0.9210, Test: 0.7995\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 07: 100%|██████████| 196615/196615 [01:28<00:00, 2216.11it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:57<00:00, 55204.87it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 07, Train: 0.9395, Val: 0.9225, Test: 0.8026\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 08: 100%|██████████| 196615/196615 [01:28<00:00, 2217.35it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:55<00:00, 55740.37it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 08, Train: 0.9395, Val: 0.9226, Test: 0.7996\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 09: 100%|██████████| 196615/196615 [01:27<00:00, 2259.50it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:53<00:00, 56433.61it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 09, Train: 0.9415, Val: 0.9233, Test: 0.8052\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 196615/196615 [01:28<00:00, 2210.09it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:03<00:00, 53525.82it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10, Train: 0.9420, Val: 0.9227, Test: 0.8096\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 196615/196615 [01:27<00:00, 2250.85it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:43<00:00, 59794.66it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11, Train: 0.9428, Val: 0.9232, Test: 0.8030\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 196615/196615 [01:25<00:00, 2309.67it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:11<00:00, 51022.47it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12, Train: 0.9358, Val: 0.9182, Test: 0.8058\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 196615/196615 [01:27<00:00, 2237.43it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:55<00:00, 55916.25it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13, Train: 0.9442, Val: 0.9252, Test: 0.8004\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 196615/196615 [01:27<00:00, 2235.32it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:04<00:00, 53137.93it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14, Train: 0.9405, Val: 0.9199, Test: 0.7950\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 196615/196615 [01:28<00:00, 2213.06it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:00<00:00, 54348.72it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15, Train: 0.9455, Val: 0.9257, Test: 0.7998\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 196615/196615 [01:26<00:00, 2286.02it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:12<00:00, 50844.19it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16, Train: 0.9473, Val: 0.9264, Test: 0.8053\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 196615/196615 [01:23<00:00, 2353.65it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:53<00:00, 56499.60it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17, Train: 0.9464, Val: 0.9252, Test: 0.8066\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 196615/196615 [01:21<00:00, 2422.94it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [02:52<00:00, 56785.00it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18, Train: 0.9467, Val: 0.9251, Test: 0.8010\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 196615/196615 [01:21<00:00, 2397.75it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:02<00:00, 53705.21it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19, Train: 0.9494, Val: 0.9264, Test: 0.8066\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 196615/196615 [01:27<00:00, 2247.66it/s]\n",
      "Evaluating: 100%|██████████| 9796116/9796116 [03:04<00:00, 53114.72it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20, Train: 0.9456, Val: 0.9252, Test: 0.8020\n"
     ]
    }
   ],
   "source": [
    "mlpinit_losses = []\n",
    "mlpinit_test_accs = []\n",
    "\n",
    "model.load_state_dict(torch.load( f'./model_mlpinit.pt'  ))\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay = 0.0)\n",
    "\n",
    "best_val_acc = final_test_acc = 0\n",
    "for epoch in range(1, 21):\n",
    "    loss, acc = train(epoch)\n",
    "    train_acc, val_acc, test_acc = test()\n",
    "    print(f'Epoch {epoch:02d}, Train: {train_acc:.4f}, Val: {val_acc:.4f}, 'f'Test: {test_acc:.4f}')\n",
    "    \n",
    "    mlpinit_losses.append(loss)\n",
    "    mlpinit_test_accs.append(test_acc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x=range( 0, 20 )\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 3))\n",
    "\n",
    "ax1.plot(x, random_losses, label='random')\n",
    "ax1.plot(x, mlpinit_losses, label='mlpinit')\n",
    "ax1.set_xlabel('epoch')\n",
    "ax1.set_ylabel('loss')\n",
    "ax1.legend()\n",
    "\n",
    "ax2.plot(x, random_test_accs, label='random')\n",
    "ax2.plot(x, mlpinit_test_accs, label='mlpinit')\n",
    "ax2.set_xlabel('epoch')\n",
    "ax2.set_ylabel('accuracy')\n",
    "ax2.legend()\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.16"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "581227cdd1283cff56f0a0aebdeca52d35d45f1fd4c65207196ef5c3d3a9bb16"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}