cnn_birnn_models_trainning.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "gather": {
          "logged": 1664553945790
        }
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/anaconda/envs/azureml_py38_PT_TF/lib/python3.8/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"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "DEVICE found:  cpu\n",
            "number of classes:  15\n",
            "/mnt/batch/tasks/shared/LS_root/mounts/clusters/mycompute1/code/Users/bredsoby\n",
            "X_train__23_features (1789827, 23)\n",
            "X_test__23_features (606432, 23)\n",
            "y_train_binary__23_features (1789827,)\n",
            "0.0     1497160\n",
            "4.0      128632\n",
            "2.0       96004\n",
            "10.0      42979\n",
            "3.0        7709\n",
            "7.0        4110\n",
            "6.0        3967\n",
            "5.0        3882\n",
            "11.0       2303\n",
            "1.0        1457\n",
            "12.0       1084\n",
            "14.0        489\n",
            "9.0          27\n",
            "13.0         16\n",
            "8.0           8\n",
            "dtype: int64\n",
            "Y_test__binary (606432,)\n",
            "classes_y:  [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n",
            "class_weights:  [7.96987630e-02 8.18955388e+01 1.24288363e+00 1.54782462e+01\n",
            " 9.27621432e-01 3.07371973e+01 3.00785984e+01 2.90320681e+01\n",
            " 1.49152250e+04 4.41932593e+03 2.77628144e+00 5.18114633e+01\n",
            " 1.10075461e+02 7.45761250e+03 2.44011861e+02]\n",
            "\n",
            "classes_class_weights: \n",
            "{0: 0.08,\n",
            " 1: 81.896,\n",
            " 2: 1.243,\n",
            " 3: 15.478,\n",
            " 4: 0.928,\n",
            " 5: 30.737,\n",
            " 6: 30.079,\n",
            " 7: 29.032,\n",
            " 8: 14915.225,\n",
            " 9: 4419.326,\n",
            " 10: 2.776,\n",
            " 11: 51.811,\n",
            " 12: 110.075,\n",
            " 13: 7457.612,\n",
            " 14: 244.012}\n"
          ]
        }
      ],
      "source": [
        "import torchmetrics\n",
        "import neural_net_model_train\n",
        "\n",
        "import utils_data_load\n",
        "\n",
        "train_loader = utils_data_load.train_loader\n",
        "test_loader = utils_data_load.test_loader\n",
        "\n",
        "input_size = (utils_data_load.X_train).shape[1]\n",
        "number_of_classes = len(utils_data_load.labels_dict)\n",
        "\n",
        "channels = 1\n",
        "batch_size= 32\n",
        "\n",
        "max_epochs = 18\n",
        "\n",
        "args_model = {\n",
        "    'number_of_classes':number_of_classes, \n",
        "    'input_shape' : (32, channels, input_size)\n",
        "    }\n",
        "\n",
        "models_trainning = neural_net_model_train.ModelsTrainning(\n",
        "                    train_loader,\n",
        "                    test_loader,\n",
        "                    max_epochs)\n",
        "\n",
        "def computeMean(values, mean_metric=torchmetrics.MeanMetric(nan_strategy=\"warn\")):\n",
        "    mean_metric.update(values)\n",
        "    mean_value = mean_metric.compute()\n",
        "    mean_metric.reset()\n",
        "\n",
        "    return mean_value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "gather": {
          "logged": 1664553945925
        }
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "# azure setting\n",
        "torch.multiprocessing.set_sharing_strategy('file_system')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "###  Trainning CNN-BIGRU model obtained from optimization with  evaluation function for f1_score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "gather": {
          "logged": 1664553946028
        }
      },
      "outputs": [],
      "source": [
        "# the resulting params from optuna optimization:\n",
        "model_parameters = \"\"\"Best trial:\n",
        "                number of the best trial:  7\n",
        "                  Value: 0.11880768090486526\n",
        "                  Params: \n",
        "                    n_layers: 3\n",
        "                    \n",
        "                    n_units_l0: 70\n",
        "                    no_strides_l0: 3\n",
        "                    n_units_l1: 85\n",
        "                    no_strides_l1: 1\n",
        "                    n_units_l2: 64\n",
        "                    no_strides_l2: 7\n",
        "                    \n",
        "                    dropout_l2: 0.2360531735539034\n",
        "                    learning_rate: 0.010737792310750963\n",
        "                    optimizer: RMSprop\n",
        "                  Evaluation function: f1_score\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "gather": {
          "logged": 1664553946250
        }
      },
      "outputs": [],
      "source": [
        "%reload_ext autoreload\n",
        "%autoreload 2\n",
        "\n",
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "DEVICE = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "gather": {
          "logged": 1664553946347
        }
      },
      "outputs": [],
      "source": [
        "#the model is made from the best parameters found by optuna \n",
        "\n",
        "class CNN_BIGRU(nn.Module):\n",
        "    def __init__(self,args):\n",
        "        super(CNN_BIGRU, self).__init__()\n",
        "        \n",
        "        kernel_size=3\n",
        "        self.number_of_classes = args[\"number_of_classes\"]\n",
        "        self.input_shape = args[\"input_shape\"]\n",
        "        self.input_size=args[\"input_shape\"][1]\n",
        "        self.batch_size = args[\"input_shape\"][0]\n",
        "        \n",
        "                \n",
        "        self.cv1 = nn.Conv1d(self.input_size, 70, kernel_size=3, stride=3,bias=False)\n",
        "        self.avgp1 = nn.AvgPool1d(kernel_size=3, stride=3)\n",
        "        self.gn1 = nn.GroupNorm(10, 70)\n",
        "        self.lrelu1 = nn.LeakyReLU(inplace=True)\n",
        "\n",
        "        self.cv2 = nn.Conv1d(70, 85, kernel_size=1, stride=1,bias=False)\n",
        "        self.avgp2 = nn.AvgPool1d(kernel_size=1, stride=1)\n",
        "        self.gn2 = nn.GroupNorm(17, 85)\n",
        "        self.lrelu2 = nn.LeakyReLU(inplace=True)\n",
        "\n",
        "        self.cv3 = nn.Conv1d(85, 64, kernel_size=1, stride=7,bias=False)\n",
        "        self.avgp3 = nn.AvgPool1d(kernel_size=1, stride=7)\n",
        "        self.gn3 = nn.GroupNorm(16, 64)\n",
        "        self.lrelu3 = nn.LeakyReLU(inplace=True)\n",
        "\n",
        "\n",
        "\n",
        "        #Expected hidden size (4, 32, 128), got [4, 32, 64]\n",
        "        self.bigru =nn.GRU(\n",
        "                    input_size=64,\n",
        "                    hidden_size=64 * 2,\n",
        "                    #hidden_size=64,\n",
        "                    num_layers=2,\n",
        "                    batch_first=True,\n",
        "                    dropout=0.236,\n",
        "                    bidirectional=True,\n",
        "                    )\n",
        "\n",
        "        self.fc_output = nn.Linear(64*4, self.batch_size)\n",
        "        #self.fc_output = nn.Linear(64*2, self.batch_size)\n",
        "        \n",
        "        self.initialize_weights()\n",
        "        \n",
        "    def forward(self, x):\n",
        "        out = self.cv1(x)\n",
        "        assert not torch.isnan(out).any()\n",
        "        out = self.avgp1(out)\n",
        "        out = self.gn1(out)\n",
        "        out = self.lrelu1(out)\n",
        "        \n",
        "        out = self.cv2(out)\n",
        "        assert not torch.isnan(out).any()\n",
        "        out = self.avgp2(out)\n",
        "        out = self.gn2(out)\n",
        "        out = self.lrelu2(out)\n",
        "        \n",
        "        \n",
        "        out = self.cv3(out)\n",
        "        assert not torch.isnan(out).any()\n",
        "        out = self.avgp3(out)\n",
        "        out = self.gn3(out)\n",
        "        out = self.lrelu3(out)        \n",
        "        \n",
        "        outputs = torch.transpose(out, 1, 2)\n",
        "        \n",
        "        h0 = torch.zeros( 2 * 2, outputs.size(0), 64*2).to(DEVICE)\n",
        "        outputs, hidden = self.bigru(outputs, h0)\n",
        "        assert not torch.isnan(outputs).any()\n",
        "\n",
        "        outputs = self.fc_output(outputs)\n",
        "        assert not torch.isnan(outputs).any()\n",
        "\n",
        "        outputs = outputs.view(batch_size, -1)\n",
        "        linear_output = (nn.Linear(outputs.shape[1], number_of_classes)).to(DEVICE)\n",
        "            \n",
        "        # apply Linear to get shape of: (batch_size,number_of_classes)\n",
        "        # the Linear is generated in this way to make the output fit the required shape and to let RNN layer be as wide as possible\n",
        "        outputs = linear_output(outputs)            \n",
        "        assert not torch.isnan(outputs).any()\n",
        "                    \n",
        "        # reshaped because CrossEntropyLoss has to match the target\n",
        "        outputs = outputs.unsqueeze(2)\n",
        "        \n",
        "        return outputs\n",
        "    \n",
        "    def initialize_weights(self):\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Conv1d):\n",
        "                nn.init.kaiming_uniform_(m.weight.data, nonlinearity=\"leaky_relu\")\n",
        "                if m.bias is not None:\n",
        "                    nn.init.constant_(m.bias.data, 0)\n",
        "            elif isinstance(m, nn.Linear):\n",
        "                torch.nn.init.kaiming_uniform_(m.weight.data, nonlinearity=\"leaky_relu\")\n",
        "                if m.bias is not None:\n",
        "                    nn.init.constant_(m.bias.data, 0)\n",
        "            elif isinstance(m, nn.GroupNorm):\n",
        "                nn.init.constant_(m.weight.data, 1)\n",
        "                nn.init.constant_(m.bias.data, 0)\n",
        "                "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "gather": {
          "logged": 1664553946504
        }
      },
      "outputs": [],
      "source": [
        "cnn_bigru_model = CNN_BIGRU(args_model)\n",
        "\n",
        "optimizer = torch.optim.RMSprop(cnn_bigru_model.parameters(), lr=0.01073, alpha=0.99, eps=1e-08, centered=False)   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "gather": {
          "logged": 1664570254733
        }
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/anaconda/envs/azureml_py38_PT_TF/lib/python3.8/site-packages/torchmetrics/utilities/prints.py:36: UserWarning: Metric `AUROC` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
            "  warnings.warn(*args, **kwargs)\n",
            "100%|██████████| 55932/55932 [13:59<00:00, 66.63it/s]\n",
            "100%|██████████| 55932/55932 [16:18<00:00, 57.15it/s]\n",
            "100%|██████████| 55932/55932 [14:42<00:00, 63.35it/s]\n",
            "100%|██████████| 55932/55932 [14:52<00:00, 62.68it/s]\n",
            "100%|██████████| 55932/55932 [14:51<00:00, 62.72it/s]\n",
            "100%|██████████| 55932/55932 [15:12<00:00, 61.29it/s]\n",
            "100%|██████████| 55932/55932 [14:49<00:00, 62.91it/s]\n",
            "100%|██████████| 55932/55932 [14:50<00:00, 62.80it/s]\n",
            "100%|██████████| 55932/55932 [14:35<00:00, 63.90it/s]\n",
            "100%|██████████| 55932/55932 [14:41<00:00, 63.46it/s]\n",
            "100%|██████████| 55932/55932 [14:44<00:00, 63.23it/s]\n",
            "100%|██████████| 55932/55932 [14:44<00:00, 63.21it/s]\n",
            "100%|██████████| 55932/55932 [14:38<00:00, 63.69it/s]\n",
            "100%|██████████| 55932/55932 [15:07<00:00, 61.61it/s]\n",
            "100%|██████████| 55932/55932 [14:59<00:00, 62.21it/s]\n",
            "100%|██████████| 55932/55932 [15:00<00:00, 62.10it/s]\n",
            "100%|██████████| 55932/55932 [14:45<00:00, 63.16it/s]\n",
            "100%|██████████| 55932/55932 [15:07<00:00, 61.65it/s]\n"
          ]
        }
      ],
      "source": [
        "models_trainning.setParameters(\n",
        "            net_model=cnn_bigru_model,\n",
        "            optimizer=optimizer\n",
        "        )\n",
        "\n",
        "accuracies_scores, loss_scores, f1_scores, auroc_scores = models_trainning.trainNetModel()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "gather": {
          "logged": 1664570255102
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Train set: Average loss: 0.0667, Average accuracy: 2.7447%,\n",
            " \t Average f1_score: 0.0667, Average Area Under ROC: 0.5000 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "print( \"\\nTrain set: Average loss: {:.4f}, Average accuracy: {:.4f}%,\\n \\t Average f1_score: {:.4f}, Average Area Under ROC: {:.4f} \\n\".format(\n",
        "                computeMean(accuracies_scores),\n",
        "                computeMean(loss_scores),\n",
        "                computeMean(f1_scores),\n",
        "                computeMean(auroc_scores),\n",
        "            )\n",
        "        )\n",
        "\n",
        "checkpoint = models_trainning.getModelCheckpoint()\n",
        "torch.save(checkpoint, \"best_optimized_models/cnn/f1_score/\"+\"cnnbigru_trainned_\"+ str(max_epochs))   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "gather": {
          "logged": 1664570257354
        }
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "from utils.helper_plotting import plotEvaluationResults\n",
        "\n",
        "plotEvaluationResults(accuracies_scores,loss_scores,f1_scores,auroc_scores,max_epochs, label=\"MLP_ver1\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "gather": {
          "logged": 1664570398109
        }
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 18951/18951 [02:13<00:00, 142.26it/s]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Test set: Average loss: 2.7287, Average accuracy: 0.0671%,\n",
            " \t  Average f1_score: 0.1131, Average Area Under ROC: 0.4735 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "models_trainning.testNetModel()"
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python38-azureml-pt-tf"
    },
    "kernelspec": {
      "display_name": "Python 3.10.6 ('pytorch_env')",
      "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.10.6"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "201b6068cbed112f118c29a6393440d4ce4dc02105f31305c61d838eb972bb93"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}