Meta_learning_EFL.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/BecomeAllan/ML-SLRC/blob/main/Meta_learning_EFL.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1zWLUeM32ASb",
      "metadata": {
        "id": "1zWLUeM32ASb"
      },
      "source": [
        "# Introduction\n",
        "\n",
        "This notebook was used to conduct a research of a agnostic-model for systematics literatures reviews classification, using [Entailment as Few-shot classification](https://arxiv.org/abs/2104.14690) and [first-order meta-learning algorithms](https://arxiv.org/abs/1803.02999) with a pre-trained language model [SciBERT](https://arxiv.org/abs/1903.10676).\n",
        "\n",
        "The etailment text used was \"It is a great text.\"."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "trqLc9E8hce9",
      "metadata": {
        "id": "trqLc9E8hce9"
      },
      "source": [
        "## Requirements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "89316599-c2d8-4b73-a490-83a852024552",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "89316599-c2d8-4b73-a490-83a852024552",
        "outputId": "0ed21fd3-b8e5-4239-e420-dcfab373f547"
      },
      "outputs": [],
      "source": [
        "!pip install transformers==4.16.2\n",
        "!pip install torchmetrics==0.8.0\n",
        "\n",
        "!pip install matplotlib==3.5.1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "0699fcf5-202b-4163-a4f1-8af69ab36e41",
      "metadata": {
        "id": "0699fcf5-202b-4163-a4f1-8af69ab36e41"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "import torch.nn.functional as F\n",
        "import torch.nn as nn\n",
        "import math\n",
        "import torch\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import time\n",
        "import transformers\n",
        "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n",
        "from sklearn.manifold import TSNE\n",
        "from copy import deepcopy, copy\n",
        "import seaborn as sns\n",
        "import matplotlib.pylab as plt\n",
        "from pprint import pprint\n",
        "import shutil\n",
        "import datetime\n",
        "import re\n",
        "import json\n",
        "from pathlib import Path\n",
        "\n",
        "SEED = 2222\n",
        "\n",
        "gen_seed = torch.Generator().manual_seed(SEED)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "q4OpUylcuk0u",
      "metadata": {
        "id": "q4OpUylcuk0u"
      },
      "source": [
        "# Useful Functions\n",
        "\n",
        "Useful function to conduct the research"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "QZv8O2GzCar3",
      "metadata": {
        "id": "QZv8O2GzCar3"
      },
      "source": [
        "## Random\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "MWboPAJ0MR-P",
      "metadata": {
        "id": "MWboPAJ0MR-P"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "\n",
        "# Random seed function\n",
        "def random_seed(value):\n",
        "    torch.backends.cudnn.deterministic=True\n",
        "    torch.manual_seed(value)\n",
        "    torch.cuda.manual_seed(value)\n",
        "    np.random.seed(value)\n",
        "    random.seed(value)\n",
        "\n",
        "# Tasks for meta-learner\n",
        "def create_batch_of_tasks(taskset, is_shuffle = True, batch_size = 4):\n",
        "    idxs = list(range(0,len(taskset)))\n",
        "    if is_shuffle:\n",
        "        random.shuffle(idxs)\n",
        "    for i in range(0,len(idxs), batch_size):\n",
        "        yield [taskset[idxs[i]] for i in range(i, min(i + batch_size,len(taskset)))]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "q9_MGXvEuQ35",
      "metadata": {
        "id": "q9_MGXvEuQ35"
      },
      "source": [
        "## Diagnosis"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "q0yYUkHN1d2y",
      "metadata": {
        "id": "q0yYUkHN1d2y"
      },
      "source": [
        "### Framework"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "EyrU457ea0ws",
      "metadata": {
        "id": "EyrU457ea0ws"
      },
      "outputs": [],
      "source": [
        "# Prepare data to process by Domain-learner\n",
        "def prepare_data(data, batch_size, tokenizer,max_seq_length,\n",
        "                 input = 'text', output = 'label',\n",
        "                 train_size_per_class = 5, global_datasets = False,\n",
        "                 treat_text_fun =None):\n",
        "  data = data.reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "  if global_datasets:\n",
        "    global data_train, data_test\n",
        "\n",
        "  # Sample task for training\n",
        "  data_train = data.groupby('label').sample(train_size_per_class, replace=False)\n",
        "  idex = data.index.isin(data_train.index)\n",
        "\n",
        "  # The Test set to label by the model\n",
        "  data_test = data[~idex].reset_index()\n",
        "\n",
        "\n",
        "  # Transform in dataset to model\n",
        "  ## Train\n",
        "  dataset_train = SLR_DataSet(\n",
        "    data = data_train.sample(frac=1),\n",
        "    input = input,\n",
        "    output = output,\n",
        "    tokenizer=tokenizer,\n",
        "    max_seq_length =max_seq_length,\n",
        "    treat_text =treat_text_fun)\n",
        "\n",
        "  ## Test\n",
        "  dataset_test = SLR_DataSet(\n",
        "    data = data_test,\n",
        "    input = input,\n",
        "    output = output,\n",
        "    tokenizer=tokenizer,\n",
        "    max_seq_length =max_seq_length,\n",
        "    treat_text =treat_text_fun)\n",
        "  \n",
        "  # Dataloaders\n",
        "  ## Train \n",
        "  data_train_loader = DataLoader(dataset_train,\n",
        "                           shuffle=True,\n",
        "                           batch_size=batch_size['train']\n",
        "                                )\n",
        "  \n",
        "  ## Test\n",
        "  if len(dataset_test) % batch_size['test'] == 1 :\n",
        "    data_test_loader = DataLoader(dataset_test,\n",
        "                                    batch_size=batch_size['test'],\n",
        "                                    drop_last=True)\n",
        "  else:\n",
        "    data_test_loader = DataLoader(dataset_test,\n",
        "                                    batch_size=batch_size['test'],\n",
        "                                    drop_last=False)\n",
        "\n",
        "  return data_train_loader, data_test_loader, data_train, data_test\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "53LKzmWYYum7",
      "metadata": {
        "id": "53LKzmWYYum7"
      },
      "outputs": [],
      "source": [
        "from tqdm import tqdm\n",
        "\n",
        "# Meta trainer\n",
        "def meta_train(data, model, device, Info,\n",
        "               print_epoch =True, size_layer=0,\n",
        "                Test_resource =None,\n",
        "                treat_text_fun =None):\n",
        "\n",
        "  # Meta-learner model\n",
        "  learner = Learner(model = model, device = device, **Info)\n",
        "  \n",
        "  # Testing tasks\n",
        "  if isinstance(Test_resource, pd.DataFrame):\n",
        "    test = MetaTask(Test_resource, num_task = 0, k_support=10, k_query=10,\n",
        "                  training=False,treat_text =treat_text_fun, **Info)\n",
        "\n",
        "\n",
        "  torch.clear_autocast_cache()\n",
        "  gc.collect()\n",
        "  torch.cuda.empty_cache()\n",
        "\n",
        "  # Meta epoch (Outer epoch)\n",
        "  for epoch in tqdm(range(Info['meta_epoch']), desc= \"Meta epoch \", ncols=80):\n",
        "      \n",
        "      # Train tasks\n",
        "      train = MetaTask(data,\n",
        "                      num_task = Info['num_task_train'],\n",
        "                      k_support=Info['k_qry'],\n",
        "                      k_query=Info['k_spt'],\n",
        "                      treat_text =treat_text_fun, **Info)\n",
        "\n",
        "      # Batch of train tasks\n",
        "      db = create_batch_of_tasks(train, is_shuffle = True, batch_size = Info[\"outer_batch_size\"])\n",
        "\n",
        "      if print_epoch:\n",
        "      # Outer loop bach training\n",
        "        for step, task_batch in enumerate(db):          \n",
        "            print(\"\\n-----------------Training Mode\",\"Meta_epoch:\", epoch ,\"-----------------\\n\")\n",
        "            \n",
        "            # meta-feedfoward (outer-feedfoward)\n",
        "            acc = learner(task_batch, valid_train= print_epoch)\n",
        "            print('Step:', step, '\\ttraining Acc:', acc)\n",
        "        \n",
        "        if isinstance(Test_resource, pd.DataFrame):\n",
        "          # Validating Model\n",
        "          if ((epoch+1) % 4) + step == 0:\n",
        "              random_seed(123)\n",
        "              print(\"\\n-----------------Testing Mode-----------------\\n\")\n",
        "              \n",
        "              # Batch of test tasks\n",
        "              db_test = create_batch_of_tasks(test, is_shuffle = False, batch_size = 1)\n",
        "              acc_all_test = []\n",
        "\n",
        "              # Looping testing tasks\n",
        "              for test_batch in db_test:\n",
        "                  acc = learner(test_batch, training = False)\n",
        "                  acc_all_test.append(acc)\n",
        "\n",
        "              print('Test acc:', np.mean(acc_all_test))\n",
        "              del acc_all_test, db_test\n",
        "\n",
        "              # Restarting training randomly\n",
        "              random_seed(int(time.time() % 10))\n",
        "\n",
        "      else:\n",
        "        for step, task_batch in enumerate(db):\n",
        "            # meta-feedfoward (outer-feedfoward)\n",
        "            acc = learner(task_batch, print_epoch, valid_train= print_epoch)\n",
        "\n",
        "  torch.clear_autocast_cache()\n",
        "  gc.collect()\n",
        "  torch.cuda.empty_cache()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "I4nKctl6csYB",
      "metadata": {
        "id": "I4nKctl6csYB"
      },
      "outputs": [],
      "source": [
        "def train_loop(data_train_loader, data_test_loader, model, device, epoch = 4, lr = 1, print_info = True, name = 'name'):\n",
        "  # Start the model's parameters\n",
        "  model_meta = deepcopy(model)\n",
        "  optimizer = Adam(model_meta.parameters(), lr=lr)\n",
        "\n",
        "  model_meta.to(device)\n",
        "  model_meta.train()\n",
        "\n",
        "  # Task epoch (Inner epoch)\n",
        "  for i in range(0, epoch):\n",
        "      all_loss = []\n",
        "\n",
        "      # Inner training batch (support set)\n",
        "      for inner_step, batch in enumerate(data_train_loader):\n",
        "          batch = tuple(t.to(device) for t in batch)\n",
        "          input_ids, attention_mask,q_token_type_ids, label_id = batch\n",
        "          \n",
        "          # Inner Feedfoward\n",
        "          loss, _, _ = model_meta(input_ids, attention_mask,q_token_type_ids, labels = label_id.squeeze())\n",
        "          \n",
        "          # compute grads\n",
        "          loss.backward()\n",
        "\n",
        "          # update parameters\n",
        "          optimizer.step()\n",
        "          optimizer.zero_grad()\n",
        "          \n",
        "          all_loss.append(loss.item())\n",
        "      \n",
        "\n",
        "      if (i % 2 == 0) & print_info:\n",
        "          print(\"Loss: \", np.mean(all_loss))\n",
        "\n",
        "\n",
        "  # Test evaluation\n",
        "  model_meta.eval()\n",
        "  all_loss = []\n",
        "  all_acc = []\n",
        "  features = []\n",
        "  labels = []\n",
        "  predi_logit = []\n",
        "\n",
        "  with torch.no_grad():\n",
        "      # Test's Batch loop\n",
        "      for inner_step, batch in enumerate(tqdm(data_test_loader,\n",
        "                                              desc=\"Test validation | \" + name,\n",
        "                                              ncols=80)) :\n",
        "        batch = tuple(t.to(device) for t in batch)\n",
        "        input_ids, attention_mask,q_token_type_ids, label_id = batch\n",
        "\n",
        "        # Predictions\n",
        "        _, feature, prediction = model_meta(input_ids, attention_mask,q_token_type_ids, labels = label_id.squeeze())\n",
        "\n",
        "        # Save batch's predictions \n",
        "        prediction = prediction.detach().cpu().squeeze()\n",
        "        label_id = label_id.detach().cpu()\n",
        "        labels.append(label_id.numpy().squeeze())\n",
        "        \n",
        "        logit = feature[1].detach().cpu()\n",
        "        predi_logit.append(logit.numpy())\n",
        "\n",
        "        feature_lat = feature[0].detach().cpu()\n",
        "        features.append(feature_lat.numpy())\n",
        "\n",
        "        # Accuracy over the test's bach\n",
        "        acc = fn.accuracy(prediction, label_id).item()\n",
        "        all_acc.append(acc)\n",
        "      del input_ids, attention_mask, label_id, batch\n",
        "\n",
        "  if print_info:\n",
        "    print(\"acc:\", np.mean(all_acc))\n",
        "\n",
        "  model_meta.to('cpu')\n",
        "  gc.collect()\n",
        "  torch.cuda.empty_cache()\n",
        "\n",
        "  del model_meta, optimizer\n",
        "\n",
        "  return map_feature_tsne(features, labels, predi_logit)\n",
        "\n",
        "# Process predictions and map the feature_map in tsne\n",
        "def map_feature_tsne(features, labels, predi_logit):\n",
        "  \n",
        "  features = np.concatenate(np.array(features,dtype=object))\n",
        "  features = torch.tensor(features.astype(np.float32)).detach().clone()\n",
        "  \n",
        "  labels = np.concatenate(np.array(labels,dtype=object))\n",
        "  labels = torch.tensor(labels.astype(int)).detach().clone()\n",
        "\n",
        "  logits = np.concatenate(np.array(predi_logit,dtype=object))\n",
        "  logits = torch.tensor(logits.astype(np.float32)).detach().clone()\n",
        "\n",
        "  # Dimention reduction\n",
        "  X_embedded = TSNE(n_components=2, learning_rate='auto',\n",
        "                    init='random').fit_transform(features.detach().clone())\n",
        "\n",
        "  return logits.detach().clone(), X_embedded, labels.detach().clone(), features.detach().clone()\n",
        "  \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "QbEOmxghkbG7",
      "metadata": {
        "id": "QbEOmxghkbG7"
      },
      "outputs": [],
      "source": [
        "def wss_calc(logit, labels, trsh = 0.5):\n",
        "  \n",
        "  # Prediction label given the threshold\n",
        "  predict_trash = torch.sigmoid(logit).squeeze() >= trsh\n",
        "  \n",
        "  # Compute confusion matrix values\n",
        "  CM = confusion_matrix(labels, predict_trash.to(int) )\n",
        "  tn, fp, fne, tp = CM.ravel()\n",
        "\n",
        "  P = (tp + fne)  \n",
        "  N = (tn + fp) \n",
        "  recall = tp/(tp+fne)\n",
        "\n",
        "  # WSS\n",
        "  wss = (tn + fne)/len(labels) -(1- recall)\n",
        "\n",
        "  # AWSS\n",
        "  awss = (tn/N - fne/P)\n",
        "\n",
        "  return {\n",
        "      \"wss\": round(wss,4),\n",
        "      \"awss\": round(awss,4),\n",
        "      \"R\": round(recall,4),\n",
        "      \"CM\": CM\n",
        "      }"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "TKnM3-9Xjql8",
      "metadata": {
        "id": "TKnM3-9Xjql8"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "from torchmetrics import functional as fn\n",
        "from sklearn.metrics import roc_curve, auc\n",
        "from sklearn.metrics import roc_auc_score\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import HTML, display, clear_output\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import warnings\n",
        "\n",
        "# Compute the metrics\n",
        "def plot(logits, X_embedded, labels, threshold, show = True,\n",
        "         namefig = \"plot\", make_plot = True, print_stats = True, save = True):\n",
        "  col = pd.MultiIndex.from_tuples([\n",
        "                                   (\"Predict\", \"0\"),\n",
        "                                   (\"Predict\", \"1\")\n",
        "                                   ])\n",
        "  index = pd.MultiIndex.from_tuples([\n",
        "                                   (\"Real\", \"0\"),\n",
        "                                   (\"Real\", \"1\")\n",
        "                                   ])\n",
        "\n",
        "  predict = torch.sigmoid(logits).detach().clone()\n",
        "\n",
        "  # Roc curve\n",
        "  fpr, tpr, thresholds = roc_curve(labels, predict.squeeze())\n",
        "\n",
        "  # Given by a Recall of 95% (threshold avaliation)\n",
        "  ## WSS\n",
        "  ### Index to recall\n",
        "  idx_wss95 = sum(tpr < 0.95)\n",
        "  ### threshold\n",
        "  thresholds95 = thresholds[idx_wss95]\n",
        "\n",
        "  ### Compute the metrics\n",
        "  wss95_info = wss_calc(logits,labels, thresholds95 )\n",
        "  acc_wss95 = fn.accuracy(predict, labels, threshold=thresholds95)\n",
        "  f1_wss95 = fn.f1_score(predict, labels, threshold=thresholds95)\n",
        "\n",
        "\n",
        "  # Given by a threshold (recall avaliation)\n",
        "  ### Compute the metrics\n",
        "  wss_info = wss_calc(logits,labels, threshold )\n",
        "  acc_wssR = fn.accuracy(predict, labels, threshold=threshold)\n",
        "  f1_wssR = fn.f1_score(predict, labels, threshold=threshold)\n",
        "\n",
        "\n",
        "  metrics= {\n",
        "      # WSS\n",
        "      \"WSS@95\": wss95_info['wss'],\n",
        "      \"AWSS@95\": wss95_info['awss'],\n",
        "      \"WSS@R\": wss_info['wss'],\n",
        "      \"AWSS@R\": wss_info['awss'],\n",
        "      # Recall\n",
        "      \"Recall_WSS@95\": wss95_info['R'],\n",
        "      \"Recall_WSS@R\": wss_info['R'],\n",
        "      # acc\n",
        "      \"acc@95\": acc_wss95.item(),\n",
        "      \"acc@R\": acc_wssR.item(),\n",
        "      # f1\n",
        "      \"f1@95\": f1_wss95.item(),\n",
        "      \"f1@R\": f1_wssR.item(),\n",
        "      # threshold 95\n",
        "      \"threshold@95\": thresholds95\n",
        "  }\n",
        "\n",
        "  # Print stats\n",
        "  if print_stats:\n",
        "    wss95= f\"WSS@95:{wss95_info['wss']}, R: {wss95_info['R']}\"\n",
        "    wss95_adj= f\"ASSWSS@95:{wss95_info['awss']}\"\n",
        "    print(wss95)\n",
        "    print(wss95_adj)\n",
        "    print('Acc.:', round(acc_wss95.item(), 4))\n",
        "    print('F1-score:', round(f1_wss95.item(), 4))\n",
        "    print(f\"threshold to wss95: {round(thresholds95, 4)}\")\n",
        "    cm = pd.DataFrame(wss95_info['CM'],\n",
        "              index=index,\n",
        "              columns=col)\n",
        "    \n",
        "    print(\"\\nConfusion matrix:\")\n",
        "    print(cm)\n",
        "    print(\"\\n---Metrics with threshold:\", threshold, \"----\\n\")\n",
        "    wss= f\"WSS@R:{wss_info['wss']}, R: {wss_info['R']}\"\n",
        "    print(wss)\n",
        "    wss_adj= f\"AWSS@R:{wss_info['awss']}\"\n",
        "    print(wss_adj)\n",
        "    print('Acc.:', round(acc_wssR.item(), 4))\n",
        "    print('F1-score:', round(f1_wssR.item(), 4))\n",
        "    cm = pd.DataFrame(wss_info['CM'],\n",
        "                index=index,\n",
        "                columns=col)\n",
        "      \n",
        "    print(\"\\nConfusion matrix:\")\n",
        "    print(cm)\n",
        "\n",
        "\n",
        "  # Plots\n",
        "\n",
        "  if make_plot:\n",
        "\n",
        "    fig, axes = plt.subplots(1, 4, figsize=(25,10))\n",
        "    alpha = torch.squeeze(predict).numpy()\n",
        "\n",
        "    # TSNE\n",
        "    p1 = sns.scatterplot(x=X_embedded[:, 0],\n",
        "                  y=X_embedded[:, 1],\n",
        "                  hue=labels,\n",
        "                  alpha=alpha, ax = axes[0]).set_title('Predictions-TSNE', size=20)\n",
        "    \n",
        "    \n",
        "    # WSS@95\n",
        "    t_wss = predict >= thresholds95\n",
        "    t_wss = t_wss.squeeze().numpy()\n",
        "    p2 = sns.scatterplot(x=X_embedded[t_wss, 0],\n",
        "                  y=X_embedded[t_wss, 1],\n",
        "                  hue=labels[t_wss],\n",
        "                  alpha=alpha[t_wss], ax = axes[1]).set_title('WSS@95', size=20)\n",
        "\n",
        "    # WSS@R\n",
        "    t = predict >= threshold\n",
        "    t = t.squeeze().numpy()\n",
        "    p3 = sns.scatterplot(x=X_embedded[t, 0],\n",
        "                  y=X_embedded[t, 1],\n",
        "                  hue=labels[t],\n",
        "                  alpha=alpha[t], ax = axes[2]).set_title(f'Predictions-threshold {threshold}', size=20)\n",
        "\n",
        "    # ROC-Curve\n",
        "    roc_auc = auc(fpr, tpr)\n",
        "    lw = 2\n",
        "    axes[3].plot(\n",
        "      fpr,\n",
        "      tpr,\n",
        "      color=\"darkorange\",\n",
        "      lw=lw,\n",
        "      label=\"ROC curve (area = %0.2f)\" % roc_auc)\n",
        "    axes[3].plot([0, 1], [0, 1], color=\"navy\", lw=lw, linestyle=\"--\")\n",
        "    axes[3].axhline(y=0.95, color='r', linestyle='-')\n",
        "    # axes[3].set(xlabel=\"False Positive Rate\", ylabel=\"True Positive Rate\")\n",
        "    axes[3].legend(loc=\"lower right\")\n",
        "    axes[3].set_title(label= \"ROC\", size = 20)\n",
        "    axes[3].set_ylabel(\"True Positive Rate\", fontsize = 15)\n",
        "    axes[3].set_xlabel(\"False Positive Rate\", fontsize = 15)\n",
        "    \n",
        "\n",
        "    if show:\n",
        "      plt.show()\n",
        "    \n",
        "    if save:\n",
        "      fig.savefig(namefig, dpi=fig.dpi)\n",
        "\n",
        "  return metrics\n",
        "\n",
        "\n",
        "def auc_plot(logits,labels, color = \"darkorange\", label = \"test\"):\n",
        "    predict = torch.sigmoid(logits).detach().clone()\n",
        "    fpr, tpr, thresholds = roc_curve(labels, predict.squeeze())\n",
        "    roc_auc = auc(fpr, tpr)\n",
        "    lw = 2\n",
        "\n",
        "    label = label + str(round(roc_auc,2))\n",
        "    # print(label)\n",
        "\n",
        "    plt.plot(\n",
        "      fpr,\n",
        "      tpr,\n",
        "      color=color,\n",
        "      lw=lw,\n",
        "      label= label \n",
        "      )\n",
        "    plt.plot([0, 1], [0, 1], color=\"navy\", lw=2, linestyle=\"--\")\n",
        "    plt.axhline(y=0.95, color='r', linestyle='-')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "N359Ak8i1lpO",
      "metadata": {
        "id": "N359Ak8i1lpO"
      },
      "source": [
        "### Visual exploration"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "8yBhi1nxheP-",
      "metadata": {
        "id": "8yBhi1nxheP-"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "from torchmetrics import functional as fn\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import roc_curve, auc\n",
        "from sklearn.metrics import roc_auc_score\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import HTML, display, clear_output\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import warnings\n",
        "\n",
        "\n",
        "# Interface to evaluation\n",
        "class diagnosis():\n",
        "  def __init__(self, names, Valid_resource, batch_size_test,\n",
        "   model,Info, device,treat_text_fun=None,start = 0):\n",
        "    self.names=names\n",
        "    self.Valid_resource=Valid_resource\n",
        "    self.batch_size_test=batch_size_test\n",
        "    self.model=model\n",
        "    self.start=start\n",
        "    self.Info = Info\n",
        "    self.device = device\n",
        "    self.treat_text_fun = treat_text_fun\n",
        "    \n",
        "\n",
        "    # BOX INPUT\n",
        "    self.value_trash = widgets.FloatText(\n",
        "        value=0.95,\n",
        "        description='threshold',\n",
        "        disabled=False\n",
        "    )\n",
        "    self.valueb = widgets.IntText(\n",
        "        value=10,\n",
        "        description='size',\n",
        "        disabled=False\n",
        "    )\n",
        "\n",
        "    # Buttons\n",
        "    self.train_b = widgets.Button(description=\"Train\")\n",
        "    self.next_b = widgets.Button(description=\"Next\")\n",
        "    self.eval_b = widgets.Button(description=\"Evaluation\")\n",
        "\n",
        "    self.hbox = widgets.HBox([self.train_b, self.valueb])\n",
        "\n",
        "    # Click buttons functions\n",
        "    self.next_b.on_click(self.Next_button)\n",
        "    self.train_b.on_click(self.Train_button)\n",
        "    self.eval_b.on_click(self.Evaluation_button)\n",
        "\n",
        "\n",
        "  # Next button\n",
        "  def Next_button(self,p):\n",
        "    clear_output()\n",
        "    self.i=self.i+1\n",
        "\n",
        "    # Select the domain data\n",
        "    self.domain = self.names[self.i]\n",
        "    self.data = self.Valid_resource[self.Valid_resource['domain'] == self.domain]\n",
        "    \n",
        "    print(\"Name:\", self.domain)\n",
        "    print(self.data['label'].value_counts())\n",
        "    display(self.hbox)\n",
        "    display(self.next_b)\n",
        "\n",
        "\n",
        "  # Train button\n",
        "  def Train_button(self, y):\n",
        "    clear_output()\n",
        "    print(self.domain)\n",
        "\n",
        "    # Prepare data for training (domain-learner)\n",
        "    self.data_train_loader, self.data_test_loader, self.data_train, self.data_test = prepare_data(self.data,\n",
        "              train_size_per_class = self.valueb.value,\n",
        "              batch_size = {'train': self.Info['inner_batch_size'],\n",
        "                            'test': self.batch_size_test},\n",
        "              max_seq_length = self.Info['max_seq_length'],\n",
        "              tokenizer = self.Info['tokenizer'],\n",
        "              input = \"text\",\n",
        "              output = \"label\",\n",
        "              treat_text_fun=self.treat_text_fun)\n",
        "\n",
        "    # Train the model and predict in the test set\n",
        "    self.logits, self.X_embedded, self.labels, self.features = train_loop(self.data_train_loader, self.data_test_loader,\n",
        "                                                        self.model, self.device,\n",
        "                                                        epoch = self.Info['inner_update_step'],\n",
        "                                                        lr=self.Info['inner_update_lr'],\n",
        "                                                        print_info=True,\n",
        "                                                        name = self.domain)\n",
        "\n",
        "    tresh_box = widgets.HBox([self.eval_b, self.value_trash])\n",
        "    display(self.hbox)\n",
        "    display(tresh_box)\n",
        "    display(self.next_b)\n",
        "\n",
        "\n",
        "  # Evaluation button\n",
        "  def Evaluation_button(self, te):\n",
        "    clear_output()\n",
        "    tresh_box = widgets.HBox([self.eval_b, self.value_trash])\n",
        "\n",
        "    print(self.domain)\n",
        "    # print(\"\\n\")\n",
        "    print(\"-------Train data-------\")\n",
        "    print(data_train['label'].value_counts())\n",
        "    print(\"-------Test data-------\")\n",
        "    print(data_test['label'].value_counts())\n",
        "    # print(\"\\n\")\n",
        "    \n",
        "    display(self.next_b)\n",
        "    display(tresh_box)\n",
        "    display(self.hbox)\n",
        "\n",
        "    # Compute metrics    \n",
        "    metrics = plot(self.logits, self.X_embedded, self.labels,\n",
        "                    threshold=self.Info['threshold'], show = True,\n",
        "                    namefig= 'test',\n",
        "                  make_plot = True,\n",
        "                  print_stats = True,\n",
        "                  save=False)\n",
        "\n",
        "  def __call__(self):\n",
        "    self.i= self.start-1\n",
        "    clear_output()\n",
        "    display(self.next_b)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "wyT3Zmk_-s0s",
      "metadata": {
        "id": "wyT3Zmk_-s0s"
      },
      "source": [
        "## Simulation attemps"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "EkVIovS4-wDD",
      "metadata": {
        "id": "EkVIovS4-wDD"
      },
      "outputs": [],
      "source": [
        "from collections import defaultdict\n",
        "\n",
        "\n",
        "\n",
        "# Simulation attemps of domain learner\n",
        "def pipeline_simulation(Valid_resource, names_to_valid, path_save,\n",
        "                        model, Info, device, initializer_model,\n",
        "                        treat_text_fun=None):\n",
        "  n_attempt  = 5\n",
        "  batch_test = 100\n",
        "\n",
        "  # Create a directory to save informations\n",
        "  for name in names_to_valid:\n",
        "    name = re.sub(\"\\.csv\", \"\",name)\n",
        "    Path(path_save  + name + \"/img\").mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "  # Dict to sabe roc curves\n",
        "  roc_stats = defaultdict(lambda: defaultdict(\n",
        "      lambda: defaultdict(\n",
        "          list\n",
        "          )\n",
        "      )\n",
        "  )\n",
        "\n",
        "\n",
        "  \n",
        "\n",
        "  all_metrics = []\n",
        "  # Loop over a list of domains\n",
        "  for name in names_to_valid:\n",
        "    \n",
        "    # Select a domain dataset\n",
        "    data = Valid_resource[Valid_resource['domain'] == name].reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "    # Attempts simulation\n",
        "    for attempt in range(n_attempt):\n",
        "      print(\"---\"*4,\"attempt\", attempt, \"---\"*4)\n",
        "      \n",
        "      # Prepare data to pass to the model\n",
        "      data_train_loader, data_test_loader,  _ , _ = prepare_data(data,\n",
        "                train_size_per_class = Info['k_spt'],\n",
        "                batch_size = {'train': Info['inner_batch_size'],\n",
        "                              'test': batch_test},\n",
        "                max_seq_length = Info['max_seq_length'],\n",
        "                tokenizer = Info['tokenizer'],\n",
        "                input = \"text\",\n",
        "                output = \"label\",\n",
        "                treat_text_fun=treat_text_fun)\n",
        "\n",
        "      # Train the model and evaluate on the test set of the domain\n",
        "      logits, X_embedded, labels, features = train_loop(data_train_loader, data_test_loader,\n",
        "                                                        model, device,\n",
        "                                                        epoch = Info['inner_update_step'],\n",
        "                                                        lr=Info['inner_update_lr'],\n",
        "                                                        print_info=False,\n",
        "                                                        name = name)\n",
        "      \n",
        "      \n",
        "      name_domain = re.sub(\"\\.csv\", \"\",name)\n",
        "\n",
        "      # Compute the metrics\n",
        "      metrics = plot(logits, X_embedded, labels,\n",
        "                    threshold=Info['threshold'], show = False,\n",
        "                    namefig= path_save  + name_domain + \"/img/\" + str(attempt) + 'plots',\n",
        "        make_plot = True, print_stats = False, save =  True)\n",
        "\n",
        "      # Compute the roc-curve\n",
        "      fpr, tpr, _ = roc_curve(labels, torch.sigmoid(logits).squeeze())\n",
        "      \n",
        "      # Save the correspoud information of the domain\n",
        "      metrics['name'] = name_domain\n",
        "      metrics['layer_size'] = Info['bert_layers']\n",
        "      metrics['attempt'] = attempt\n",
        "      roc_stats[name_domain][str(Info['bert_layers'])]['fpr'].append(fpr.tolist())\n",
        "      roc_stats[name_domain][str(Info['bert_layers'])]['tpr'].append(tpr.tolist())\n",
        "      all_metrics.append(metrics)\n",
        "\n",
        "      # Save the metrics and the roc curve  of the attemp\n",
        "      pd.DataFrame(all_metrics).to_csv(path_save+ \"metrics.csv\")\n",
        "      roc_path =  path_save + \"roc_stats.json\"\n",
        "      with open(roc_path, 'w') as fp:\n",
        "          json.dump(roc_stats, fp)\n",
        "\n",
        "\n",
        "      del fpr, tpr, logits, X_embedded, labels\n",
        "      del features, metrics,  _\n",
        "\n",
        "\n",
        "  # Save the information used to evaluate the validation resource\n",
        "  save_info = Info.copy()\n",
        "  save_info['model'] = initializer_model.tokenizer.name_or_path\n",
        "  save_info.pop(\"tokenizer\")\n",
        "  save_info.pop(\"bert_layers\")\n",
        "\n",
        "  info_path =  path_save+\"info.json\"\n",
        "  with open(info_path, 'w') as fp:\n",
        "      json.dump(save_info, fp)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "tmpTVGPECdy2",
      "metadata": {
        "id": "tmpTVGPECdy2"
      },
      "source": [
        "## Statistics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "Mcy0Dss_ChtU",
      "metadata": {
        "id": "Mcy0Dss_ChtU"
      },
      "outputs": [],
      "source": [
        "# Loading dataset statistics\n",
        "def load_data_statistics(paths):\n",
        "  size = []\n",
        "  pos = []\n",
        "  neg = []\n",
        "  for p in paths:\n",
        "    data = pd.read_csv(p) \n",
        "    data = data.dropna()\n",
        "    # Dataset size\n",
        "    size.append(len(data))\n",
        "    # Number of positive labels\n",
        "    pos.append(data['labels'].value_counts()[1])\n",
        "    # Number of negative labels\n",
        "    neg.append(data['labels'].value_counts()[0])\n",
        "  del data\n",
        "\n",
        "  info_load = pd.DataFrame({\n",
        "      \"size\":size,\n",
        "      \"pos\":pos,\n",
        "      \"neg\":neg,\n",
        "      \"names\":names,\n",
        "      \"paths\": paths })\n",
        "  return info_load\n",
        "\n",
        "# Loading the datasets\n",
        "def load_data(train_info_load):\n",
        "\n",
        "  col = ['abstract','title', 'labels', 'domain']\n",
        "\n",
        "  data_train = pd.DataFrame(columns=col)\n",
        "  for p in train_info_load['paths']:  \n",
        "    data_temp = pd.read_csv(p).loc[:, ['labels', 'title', 'abstract']]\n",
        "    data_temp = pd.read_csv(p).loc[:, ['labels', 'title', 'abstract']]\n",
        "    data_temp['domain'] = os.path.basename(p)\n",
        "    data_train = pd.concat([data_train, data_temp])\n",
        "    \n",
        "  data_train['text'] = data_train['title'] + data_train['abstract'].replace(np.nan, '')\n",
        "\n",
        "  return( data_train \\\n",
        "            .replace({\"labels\":{0:\"negative\", 1:'positive'}})\\\n",
        "            .rename({\"labels\":\"label\"} , axis=1)\\\n",
        "            .loc[ :,(\"text\",\"domain\",\"label\")]\n",
        "        )"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9kxoLXspGo2C",
      "metadata": {
        "id": "9kxoLXspGo2C"
      },
      "source": [
        "# Importing data\n",
        "\n",
        "The 64 topic-agnostic labeled datasets proposed can be downloaded and mounted below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "1XJy380z06mX",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1XJy380z06mX",
        "outputId": "4a4582da-e4fc-44d6-ec07-70cea474ca01"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2022-05-19 00:23:33--  https://www.dropbox.com/sh/or0eyfo8znyu2kp/AABxXJVII48U0vY8TT3Bbp6Ea?dl=0\n",
            "Resolving www.dropbox.com (www.dropbox.com)... 162.125.9.18, 2620:100:601b:18::a27d:812\n",
            "Connecting to www.dropbox.com (www.dropbox.com)|162.125.9.18|:443... connected.\n",
            "HTTP request sent, awaiting response... 301 Moved Permanently\n",
            "Location: /sh/raw/or0eyfo8znyu2kp/AABxXJVII48U0vY8TT3Bbp6Ea [following]\n",
            "--2022-05-19 00:23:34--  https://www.dropbox.com/sh/raw/or0eyfo8znyu2kp/AABxXJVII48U0vY8TT3Bbp6Ea\n",
            "Reusing existing connection to www.dropbox.com:443.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://uc2a9ed25c05883e48d9eb737912.dl.dropboxusercontent.com/zip_download_get/BI4xwFjlN8Biej6ngl6A4uDkjmQO-XcuMRoV1YlUkYFdNHRQ7VfJ4kg2S8-2Lmo2stcBPSNNvHl7HcvOX9V7AZ1cfM2gQ-31SNIQm4bkbXh0_A# [following]\n",
            "--2022-05-19 00:23:34--  https://uc2a9ed25c05883e48d9eb737912.dl.dropboxusercontent.com/zip_download_get/BI4xwFjlN8Biej6ngl6A4uDkjmQO-XcuMRoV1YlUkYFdNHRQ7VfJ4kg2S8-2Lmo2stcBPSNNvHl7HcvOX9V7AZ1cfM2gQ-31SNIQm4bkbXh0_A\n",
            "Resolving uc2a9ed25c05883e48d9eb737912.dl.dropboxusercontent.com (uc2a9ed25c05883e48d9eb737912.dl.dropboxusercontent.com)... 162.125.9.15, 2620:100:601b:15::a27d:80f\n",
            "Connecting to uc2a9ed25c05883e48d9eb737912.dl.dropboxusercontent.com (uc2a9ed25c05883e48d9eb737912.dl.dropboxusercontent.com)|162.125.9.15|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 494507156 (472M) [application/zip]\n",
            "Saving to: ‘data.zip’\n",
            "\n",
            "data.zip            100%[===================>] 471.60M  68.2MB/s    in 7.3s    \n",
            "\n",
            "2022-05-19 00:23:42 (64.3 MB/s) - ‘data.zip’ saved [494507156/494507156]\n",
            "\n",
            "Archive:  data.zip\n",
            "warning:  stripped absolute path spec from /\n",
            "mapname:  conversion of  failed\n",
            "replace SLR_data/asreview/Bos_2018.csv? [y]es, [n]o, [A]ll, [N]one, [r]ename: A\n",
            " extracting: SLR_data/asreview/Bos_2018.csv  \n",
            " extracting: SLR_data/asreview/Hall_2012.csv  \n",
            " extracting: SLR_data/asreview/Kwok_2020.csv  \n",
            " extracting: SLR_data/asreview/cohen/ADHD.csv  \n",
            " extracting: SLR_data/asreview/Wahono_2015.csv  \n",
            " extracting: SLR_data/asreview/van_Dis_2020.csv  \n",
            " extracting: SLR_data/asreview/Wolters_2018.csv  \n",
            " extracting: SLR_data/asreview/cohen/NSAIDS.csv  \n",
            " extracting: SLR_data/asreview/cohen/Opiods.csv  \n",
            " extracting: SLR_data/asreview/cohen/Statins.csv  \n",
            " extracting: SLR_data/asreview/Nagtegaal_2019.csv  \n",
            " extracting: SLR_data/asreview/cohen/Triptans.csv  \n",
            " extracting: SLR_data/asreview/Kitchenham_2010.csv  \n",
            " extracting: SLR_data/asreview/Radjenovic_2013.csv  \n",
            " extracting: SLR_data/asreview/cohen/Estrogens.csv  \n",
            " extracting: SLR_data/asreview/Bannach-Brown_2019.csv  \n",
            " extracting: SLR_data/asreview/van_de_Schoot_2017.csv  \n",
            " extracting: SLR_data/asreview/cohen/BetaBlockers.csv  \n",
            " extracting: SLR_data/asreview/cohen/ACEInhibitors.csv  \n",
            " extracting: SLR_data/asreview/cohen/Antihistamines.csv  \n",
            " extracting: SLR_data/asreview/Appenzeller-Herzog_2020.csv  \n",
            " extracting: SLR_data/SWIFT systematic review data/BPA.csv  \n",
            " extracting: SLR_data/asreview/cohen/OralHypoglycemics.csv  \n",
            " extracting: SLR_data/asreview/cohen/UrinaryIncontinence.csv  \n",
            " extracting: SLR_data/SWIFT systematic review data/README.txt  \n",
            " extracting: SLR_data/asreview/cohen/ProtonPumpInhibitors.csv  \n",
            " extracting: SLR_data/SWIFT systematic review data/Fluoride.csv  \n",
            " extracting: SLR_data/asreview/cohen/AtypicalAntipsychotics.csv  \n",
            " extracting: SLR_data/asreview/cohen/CalciumChannelBlockers.csv  \n",
            " extracting: SLR_data/SWIFT systematic review data/Neuropain.csv  \n",
            " extracting: SLR_data/SWIFT systematic review data/PFOS-PFOA.csv  \n",
            " extracting: SLR_data/asreview/cohen/SkeletalMuscleRelaxants.csv  \n",
            " extracting: Model/2022_04_26_hr_19_54_15(GOOD)_avaliation/Info.json  \n",
            " extracting: SLR_data/SWIFT systematic review data/Transgenerational.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Readme.txt  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Vascular_access.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Pregnancy_medication.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Total_knee_replacement.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Hallux_valgus_prognostic.csv  \n",
            " extracting: SLR_data/Automatic classification of literature in systematic reviews on food safety/README.txt  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Head_and_neck_cancer_bone.csv  \n",
            " extracting: SLR_data/Automatic classification of literature in systematic reviews on food safety/cereals.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Shoulderdystocia_recurrence.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Head_and_neck_cancer_imaging.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Obstetric_emergency_training.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Shoulder_replacement_surgery.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Shoulderdystocia_positioning.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Post_intensive_care_treatment.csv  \n",
            " extracting: SLR_data/Automatic classification of literature in systematic reviews on food safety/Leafy_Greens.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Shoulder_replacement_diagnostic.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Distal_radius_fractures_approach.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/ReadME.txt  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR4_Li.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR5_Lv.csv  \n",
            " extracting: SLR_data/Automatic classification of literature in systematic reviews on food safety/cereals_Future_set.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR11_Li.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR8_Liu.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/citation.png  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR1_Yang.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR2_Meng.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR6_Wang.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR7_Zhou.csv  \n",
            " extracting: SLR_data/Medical Guidelines Dutch Association Medical Specialists/Distal_radius_fractures_closed_reduction.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR3_Segelov.csv  \n",
            " extracting: SLR_data/Automatic classification of literature in systematic reviews on food safety/Leafy_Greens_Future_set.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR9_Douxfils.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/citation_name.png  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR10_Kourbeti.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR12_Cavender.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR14_Funakoshi.csv  \n",
            " extracting: SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge to machine learning_/SR13_Chatterjee.csv  \n",
            " extracting: OriData/DATA_SLR.zip    \n"
          ]
        }
      ],
      "source": [
        "!wget -O data.zip https://www.dropbox.com/sh/or0eyfo8znyu2kp/AABxXJVII48U0vY8TT3Bbp6Ea?dl=0\n",
        "!unzip data.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "c246e204-6d19-4dbe-b089-d7834f5767ce",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c246e204-6d19-4dbe-b089-d7834f5767ce",
        "outputId": "d66a45a2-80c1-48a9-9b29-b146382205e8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR4_Li.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR8_Liu.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR9_Douxfils.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR6_Wang.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR2_Meng.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR13_Chatterjee.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR14_Funakoshi.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR3_Segelov.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR11_Li.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR5_Lv.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR12_Cavender.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR10_Kourbeti.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR1_Yang.csv',\n",
            " 'SLR_data/Screening PubMed abstracts_ is class imbalance always a challenge '\n",
            " 'to machine learning_/SR7_Zhou.csv',\n",
            " 'SLR_data/Automatic classification of literature in systematic reviews on '\n",
            " 'food safety/cereals_Future_set.csv',\n",
            " 'SLR_data/Automatic classification of literature in systematic reviews on '\n",
            " 'food safety/cereals.csv',\n",
            " 'SLR_data/Automatic classification of literature in systematic reviews on '\n",
            " 'food safety/Leafy_Greens.csv',\n",
            " 'SLR_data/Automatic classification of literature in systematic reviews on '\n",
            " 'food safety/Leafy_Greens_Future_set.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Obstetric_emergency_training.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Pregnancy_medication.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Head_and_neck_cancer_bone.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Shoulder_replacement_surgery.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Shoulderdystocia_positioning.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Shoulder_replacement_diagnostic.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Head_and_neck_cancer_imaging.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Post_intensive_care_treatment.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Distal_radius_fractures_approach.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Shoulderdystocia_recurrence.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Total_knee_replacement.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Vascular_access.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Hallux_valgus_prognostic.csv',\n",
            " 'SLR_data/Medical Guidelines Dutch Association Medical '\n",
            " 'Specialists/Distal_radius_fractures_closed_reduction.csv',\n",
            " 'SLR_data/SWIFT systematic review data/PFOS-PFOA.csv',\n",
            " 'SLR_data/SWIFT systematic review data/Neuropain.csv',\n",
            " 'SLR_data/SWIFT systematic review data/Fluoride.csv',\n",
            " 'SLR_data/SWIFT systematic review data/Transgenerational.csv',\n",
            " 'SLR_data/SWIFT systematic review data/BPA.csv',\n",
            " 'SLR_data/asreview/Kitchenham_2010.csv',\n",
            " 'SLR_data/asreview/Bos_2018.csv',\n",
            " 'SLR_data/asreview/Nagtegaal_2019.csv',\n",
            " 'SLR_data/asreview/Wahono_2015.csv',\n",
            " 'SLR_data/asreview/Hall_2012.csv',\n",
            " 'SLR_data/asreview/Wolters_2018.csv',\n",
            " 'SLR_data/asreview/Appenzeller-Herzog_2020.csv',\n",
            " 'SLR_data/asreview/van_Dis_2020.csv',\n",
            " 'SLR_data/asreview/van_de_Schoot_2017.csv',\n",
            " 'SLR_data/asreview/Radjenovic_2013.csv',\n",
            " 'SLR_data/asreview/Bannach-Brown_2019.csv',\n",
            " 'SLR_data/asreview/Kwok_2020.csv',\n",
            " 'SLR_data/asreview/cohen/ProtonPumpInhibitors.csv',\n",
            " 'SLR_data/asreview/cohen/ACEInhibitors.csv',\n",
            " 'SLR_data/asreview/cohen/UrinaryIncontinence.csv',\n",
            " 'SLR_data/asreview/cohen/Opiods.csv',\n",
            " 'SLR_data/asreview/cohen/OralHypoglycemics.csv',\n",
            " 'SLR_data/asreview/cohen/NSAIDS.csv',\n",
            " 'SLR_data/asreview/cohen/Statins.csv',\n",
            " 'SLR_data/asreview/cohen/AtypicalAntipsychotics.csv',\n",
            " 'SLR_data/asreview/cohen/Antihistamines.csv',\n",
            " 'SLR_data/asreview/cohen/Triptans.csv',\n",
            " 'SLR_data/asreview/cohen/CalciumChannelBlockers.csv',\n",
            " 'SLR_data/asreview/cohen/Estrogens.csv',\n",
            " 'SLR_data/asreview/cohen/BetaBlockers.csv',\n",
            " 'SLR_data/asreview/cohen/ADHD.csv',\n",
            " 'SLR_data/asreview/cohen/SkeletalMuscleRelaxants.csv']\n"
          ]
        }
      ],
      "source": [
        "import glob\n",
        "import os\n",
        "\n",
        "# Paths and names of the domains datasets\n",
        "path = 'SLR_data'\n",
        "paths = glob.glob(f\"{path}/**/*.csv\", recursive=True)\n",
        "pprint(paths)\n",
        "\n",
        "names = [os.path.basename(p) for p in paths]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "uZMuTuO6t1qq",
      "metadata": {
        "id": "uZMuTuO6t1qq"
      },
      "source": [
        "## Evaluate text data\n",
        "\n",
        "Some pre analysis of the text is required to handle with the miss/over information "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "Qzsfno8qtzzz",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49,
          "referenced_widgets": [
            "aefafdb701fc4395ab7f321eff068d8d",
            "9dd08a63b9cc423989b25be15460f129",
            "53f6da0f43364fd9a268584d2c519ec7",
            "dc1390bdc7eb42279aed3030a5bc77e4",
            "e94b4e96e37a4761a360f9b83cf7c7db",
            "d1bca0c60e9a4c85ace130b9d00c5d0d",
            "dec715330b2d42e49d4bdba7f950dd80",
            "e91597dc946a4fe49641997c8b235a99"
          ]
        },
        "id": "Qzsfno8qtzzz",
        "outputId": "111b5a4f-96e4-4704-b2e7-e5aa615e3d61"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "aefafdb701fc4395ab7f321eff068d8d",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(Button(description='Previous', style=ButtonStyle()), Button(description='Next', style=ButtonSty…"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Untreated text data { display-mode: \"form\" }\n",
        "\n",
        "import pandas as pd\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import HTML, display, clear_output\n",
        "from pprint import pprint\n",
        "import unicodedata\n",
        "\n",
        "# Loading data\n",
        "def handle_data(path):\n",
        "  data = pd.read_csv(path)\n",
        "  print()\n",
        "  sample = data.sample(1)\n",
        "  text =  sample['abstract'].values[0]\n",
        "  label = sample['labels'].values[0]\n",
        "  new_text = unicodedata.normalize(\"NFKD\",str(text))\n",
        "  print(f\"Label = {label}\")\n",
        "  print(f\"len(text) = {len(new_text)}\")\n",
        "  pprint(new_text)\n",
        "  print()\n",
        "i=0\n",
        "\n",
        "# Next button\n",
        "def next_button(p):\n",
        "  global i\n",
        "  i=i+1\n",
        "  try:\n",
        "    clear_output()\n",
        "    display(hbox)\n",
        "    print(f\"File: {names[i]}\")\n",
        "    handle_data(paths[i])\n",
        "    global ref\n",
        "    ref = paths[i]\n",
        "    print(f\"path: {paths[i]}\")\n",
        "    # print(f\"Control number: {i}\")\n",
        "  except  Exception as inst:\n",
        "    print(inst)\n",
        "    i=len(paths)\n",
        "    print('End')\n",
        "\n",
        "# Previous Button\n",
        "def prev_button(p):\n",
        "  global i\n",
        "  i=i-1\n",
        "  try:\n",
        "    clear_output()\n",
        "    display(hbox)\n",
        "    print(f\"File: {names[i]}\")\n",
        "    handle_data(paths[i])\n",
        "    global ref\n",
        "    ref = paths[i]\n",
        "    print(f\"path: {paths[i]}\")\n",
        "    # print(f\"Control number: {i}\")\n",
        "  except  Exception as inst:\n",
        "    print(inst)\n",
        "    i=0\n",
        "    print('End')\n",
        "\n",
        "next_b = widgets.Button(description=\"Next\")\n",
        "previous_b = widgets.Button(description=\"Previous\")\n",
        "\n",
        "hbox = widgets.HBox([previous_b, next_b])\n",
        "display(hbox)\n",
        "\n",
        "next_b.on_click(next_button)\n",
        "previous_b.on_click(prev_button)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "op1ERM4lqODR",
      "metadata": {
        "id": "op1ERM4lqODR"
      },
      "source": [
        "### Treat text data\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "SQc7P9dOqQA0",
      "metadata": {
        "id": "SQc7P9dOqQA0"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import unicodedata\n",
        "import re\n",
        "\n",
        "\n",
        "# Undesirable patterns within texts\n",
        "patterns = {\n",
        "    'CONCLUSIONS AND IMPLICATIONS':'',\n",
        "    'BACKGROUND AND PURPOSE':'',\n",
        "    'EXPERIMENTAL APPROACH':'',\n",
        "    'KEY RESULTS AEA':'',\n",
        "    '©':'',\n",
        "    '®':'',\n",
        "    'μ':'',\n",
        "    '(C)':'',\n",
        "    'OBJECTIVE:':'',\n",
        "    'MATERIALS AND METHODS:':'',\n",
        "    'SIGNIFICANCE:':'',\n",
        "    'BACKGROUND:':'',\n",
        "    'RESULTS:':'',\n",
        "    'METHODS:':'',\n",
        "    'CONCLUSIONS:':'',\n",
        "    'AIM:':'',\n",
        "    'STUDY DESIGN:':'',\n",
        "    'CLINICAL RELEVANCE:':'',\n",
        "    'CONCLUSION:':'',\n",
        "    'HYPOTHESIS:':'',\n",
        "    'CLINICAL RELEVANCE:':'',\n",
        "    'Questions/Purposes:':'',\n",
        "    'Introduction:':'',\n",
        "    'PURPOSE:':'',\n",
        "    'PATIENTS AND METHODS:':'',\n",
        "    'FINDINGS:':'',\n",
        "    'INTERPRETATIONS:':'',\n",
        "    'FUNDING:':'',\n",
        "    'PROGRESS:':'',\n",
        "    'CONTEXT:':'',\n",
        "    'MEASURES:':'',\n",
        "    'DESIGN:':'',\n",
        "    'BACKGROUND AND OBJECTIVES:':'',\n",
        "    '<p>':'',\n",
        "    '</p>':'',\n",
        "    '<<ETX>>':'',\n",
        "    '+/-':'',\n",
        "    }\n",
        " \n",
        "patterns = {x.lower():y for x,y in patterns.items()}\n",
        "\n",
        "class treat_text:\n",
        "  def __init__(self, patterns):\n",
        "    self.patterns = patterns\n",
        "\n",
        "  def __call__(self,text):\n",
        "    text = unicodedata.normalize(\"NFKD\",str(text))\n",
        "    text = multiple_replace(self.patterns,text.lower())\n",
        "    text = re.sub('(\\(.+\\))|(\\[.+\\])|( \\d )|(<)|(>)|(- )','', text)\n",
        "    text = re.sub('( +)',' ', text)\n",
        "    text = re.sub('(, ,)|(,,)',',', text)\n",
        "    text = re.sub('(%)|(per cent)',' percent', text)\n",
        "    return text\n",
        "\n",
        "# Regex multiple replace function\n",
        "def multiple_replace(dict, text):\n",
        "\n",
        "  # Building regex from dict keys\n",
        "  regex = re.compile(\"(%s)\" % \"|\".join(map(re.escape, dict.keys())))\n",
        "\n",
        "  # Substitution\n",
        "  return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) \n",
        "\n",
        "\n",
        "\n",
        "treat_text_fun = treat_text(patterns)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "v277Bsj1u9ZH",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49,
          "referenced_widgets": [
            "10c413604972498c9c18b6edd7a3ff04",
            "4a9e3076d412448a93f78afa49c327c4",
            "cc0ba4567b51479b8018c50a84c75c91",
            "a1ba9712b5c940edad22cb5793eb32e5",
            "6381629d0ea94508a1e75d0a1307616e",
            "898677ad283547669a1a49c42a7c6dde",
            "041423664fae4effab4e45f7b36e821b",
            "4043334cb0b1460185130dcaa68e490a"
          ]
        },
        "id": "v277Bsj1u9ZH",
        "outputId": "786461a3-45f4-4ae0-e7a5-08a4ea2cd5df"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "10c413604972498c9c18b6edd7a3ff04",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(Button(description='Previous', style=ButtonStyle()), Button(description='Next', style=ButtonSty…"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Treated text data { display-mode: \"form\" }\n",
        "\n",
        "import pandas as pd\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import HTML, display, clear_output\n",
        "import unicodedata\n",
        "import re\n",
        "\n",
        "\n",
        "def handle_data(path):\n",
        "  data = pd.read_csv(path)\n",
        "  # print('Columns:')\n",
        "  # print(data.columns)\n",
        "  print()\n",
        "  sample = data.sample(1)\n",
        "  text =  sample['abstract'].values[0]\n",
        "  label = sample['labels'].values[0]\n",
        "  new_text = treat_text_fun(text)\n",
        "  print(f\"Label = {label}\")\n",
        "  print(f\"len(text) = {len(new_text)}\")\n",
        "  pprint(new_text)\n",
        "  print()\n",
        "\n",
        "i=0\n",
        "\n",
        "# Next button\n",
        "def next_button(p):\n",
        "  global i\n",
        "  i=i+1\n",
        "  try:\n",
        "    clear_output()\n",
        "    display(hbox)\n",
        "    print(f\"File: {names[i]}\")\n",
        "    handle_data(paths[i])\n",
        "    global ref\n",
        "    ref = paths[i]\n",
        "    print(f\"path: {paths[i]}\")\n",
        "    # print(f\"Control number: {i}\")\n",
        "  except  Exception as inst:\n",
        "    print(inst)\n",
        "    i=len(paths)\n",
        "    print('End')\n",
        "\n",
        "# Previous Button\n",
        "def prev_button(p):\n",
        "  global i\n",
        "  i=i-1\n",
        "  try:\n",
        "    clear_output()\n",
        "    display(hbox)\n",
        "    print(f\"File: {names[i]}\")\n",
        "    handle_data(paths[i])\n",
        "    global ref\n",
        "    ref = paths[i]\n",
        "    print(f\"path: {paths[i]}\")\n",
        "    # print(f\"Control number: {i}\")\n",
        "  except  Exception as inst:\n",
        "    print(inst)\n",
        "    i=0\n",
        "    print('End')\n",
        "\n",
        "next_b = widgets.Button(description=\"Next\")\n",
        "previous_b = widgets.Button(description=\"Previous\")\n",
        "\n",
        "hbox = widgets.HBox([previous_b, next_b])\n",
        "display(hbox)\n",
        "\n",
        "next_b.on_click(next_button)\n",
        "previous_b.on_click(prev_button)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "yV9633efG0Ql",
      "metadata": {
        "id": "yV9633efG0Ql"
      },
      "source": [
        "# Downloading pre-trained model\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "f0430dcb-8618-4c65-8d4c-aa9634806c66",
      "metadata": {
        "id": "f0430dcb-8618-4c65-8d4c-aa9634806c66"
      },
      "outputs": [],
      "source": [
        "# Fetching pre-trained model and tokenizer\n",
        "class initializer:\n",
        "  def __init__(self, MODEL_NAME, **config):    \n",
        "    self.MODEL_NAME = MODEL_NAME\n",
        "\n",
        "    model = config.get(\"model\")\n",
        "    tokenizer = config.get(\"tokenizer\")\n",
        "\n",
        "    # Model\n",
        "    self.model = model.from_pretrained(MODEL_NAME, \n",
        "                                       return_dict=True,\n",
        "                                       output_attentions = False)\n",
        "    # Tokenizer\n",
        "    self.tokenizer = tokenizer.from_pretrained(MODEL_NAME,\n",
        "                                               do_lower_case = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "id": "0008c783-fd77-467a-a216-a4e650186603",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0008c783-fd77-467a-a216-a4e650186603",
        "outputId": "6b89c585-9fe5-4222-95a8-a01c2d87cd99",
        "tags": []
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Some weights of the model checkpoint at allenai/scibert_scivocab_uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight']\n",
            "- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
            "- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
            "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at allenai/scibert_scivocab_uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ],
      "source": [
        "# Model and tokenizer of choice\n",
        "config = {\n",
        "    \"model\": AutoModelForSequenceClassification,\n",
        "    \"tokenizer\": AutoTokenizer\n",
        "     }\n",
        "\n",
        "# Pre-trained model initializer (uncased sciBERT)\n",
        "initializer_model = initializer('allenai/scibert_scivocab_uncased', **config)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dd636d02-621e-4c60-845a-ddc41aef74b5",
      "metadata": {
        "id": "dd636d02-621e-4c60-845a-ddc41aef74b5",
        "tags": []
      },
      "source": [
        "# Meta-Learner - Systematic Literature Review Classifier (ML-SLRC)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "VsSjC6d3MsDd",
      "metadata": {
        "id": "VsSjC6d3MsDd"
      },
      "source": [
        "Functions based on the repository: https://github.com/mailong25/meta-learning-bert"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "cQoegkRPGA-b",
      "metadata": {
        "id": "cQoegkRPGA-b"
      },
      "source": [
        "## Domain Learner\n",
        "\n",
        "Domain learner is the phase that the model learn one task as a singular model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "id": "51fdac80-9f2e-44d0-86ec-d93babf9d419",
      "metadata": {
        "id": "51fdac80-9f2e-44d0-86ec-d93babf9d419"
      },
      "outputs": [],
      "source": [
        "# Pre-trained model\n",
        "class Encoder(nn.Module):\n",
        "  def __init__(self, layers, freeze_bert, model):\n",
        "    super(Encoder, self).__init__()\n",
        "\n",
        "    # Dummy Parameter\n",
        "    self.dummy_param = nn.Parameter(torch.empty(0))\n",
        "    \n",
        "    # Pre-trained model\n",
        "    self.model = deepcopy(model)\n",
        "\n",
        "    # Freezing bert parameters\n",
        "    if freeze_bert:\n",
        "      for param in self.model.parameters():\n",
        "        param.requires_grad = freeze_bert\n",
        "\n",
        "    # Selecting hidden layers of the pre-trained model\n",
        "    old_model_encoder = self.model.encoder.layer\n",
        "    new_model_encoder = nn.ModuleList()\n",
        "    \n",
        "    for i in layers:\n",
        "      new_model_encoder.append(old_model_encoder[i])\n",
        "\n",
        "    self.model.encoder.layer = new_model_encoder\n",
        "  \n",
        "  # Feed forward\n",
        "  def forward(self, **x):\n",
        "    return self.model(**x)['pooler_output']\n",
        "\n",
        "# Complete model\n",
        "class SLR_Classifier(nn.Module):\n",
        "  def __init__(self, **data):\n",
        "    super(SLR_Classifier, self).__init__()\n",
        "\n",
        "    # Dummy Parameter\n",
        "    self.dummy_param = nn.Parameter(torch.empty(0))\n",
        "\n",
        "    # Loss function\n",
        "    # Binary Cross Entropy with logits reduced to mean\n",
        "    self.loss_fn = nn.BCEWithLogitsLoss(reduction = 'mean',\n",
        "                                        pos_weight=torch.FloatTensor([data.get(\"pos_weight\",  2.5)]))\n",
        "\n",
        "    # Pre-trained model\n",
        "    self.Encoder = Encoder(layers = data.get(\"bert_layers\",  range(12)),\n",
        "                           freeze_bert = data.get(\"freeze_bert\",  False),\n",
        "                           model = data.get(\"model\"),\n",
        "                           )\n",
        "\n",
        "    # Feature Map Layer\n",
        "    self.feature_map = nn.Sequential(\n",
        "            # nn.LayerNorm(self.Encoder.model.config.hidden_size),\n",
        "            nn.BatchNorm1d(self.Encoder.model.config.hidden_size),\n",
        "            # nn.Dropout(data.get(\"drop\", 0.5)),\n",
        "            nn.Linear(self.Encoder.model.config.hidden_size, 200),\n",
        "            nn.Dropout(data.get(\"drop\", 0.5)),\n",
        "        )\n",
        "\n",
        "    # Classifier Layer\n",
        "    self.classifier = nn.Sequential(\n",
        "            # nn.LayerNorm(self.Encoder.model.config.hidden_size),\n",
        "            # nn.Dropout(data.get(\"drop\", 0.5)),\n",
        "            # nn.BatchNorm1d(self.Encoder.model.config.hidden_size),\n",
        "            # nn.Dropout(data.get(\"drop\", 0.5)),\n",
        "            nn.Tanh(),\n",
        "            nn.Linear(200, 1)\n",
        "        )\n",
        "\n",
        "    # Initializing layer parameters\n",
        "    nn.init.normal_(self.feature_map[1].weight, mean=0, std=0.00001)\n",
        "    nn.init.zeros_(self.feature_map[1].bias)\n",
        "\n",
        "  # Feed forward\n",
        "  def forward(self, input_ids, attention_mask, token_type_ids, labels):\n",
        "    \n",
        "    predict = self.Encoder(**{\"input_ids\":input_ids,\n",
        "                              \"attention_mask\":attention_mask,\n",
        "                              \"token_type_ids\":token_type_ids})\n",
        "    feature = self.feature_map(predict)\n",
        "    logit = self.classifier(feature)\n",
        "\n",
        "    predict = torch.sigmoid(logit)\n",
        "    \n",
        "    # Loss function \n",
        "    loss = self.loss_fn(logit.to(torch.float), labels.to(torch.float).unsqueeze(1))\n",
        "\n",
        "    return [loss, [feature, logit], predict]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "FwcGM27pSbDt",
      "metadata": {
        "id": "FwcGM27pSbDt"
      },
      "source": [
        "## Meta-Learner\n",
        "\n",
        "Meta-learner is the phase that the model learn to learn tasks."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "id": "vub8I7nUyFwz",
      "metadata": {
        "id": "vub8I7nUyFwz"
      },
      "outputs": [],
      "source": [
        "from torch import nn\n",
        "from torch.nn import functional as F\n",
        "from torch.utils.data import TensorDataset, DataLoader, RandomSampler\n",
        "from torch.optim import Adam\n",
        "from torch.nn import CrossEntropyLoss\n",
        "from transformers import BertForSequenceClassification\n",
        "from copy import deepcopy\n",
        "import gc\n",
        "from sklearn.metrics import accuracy_score\n",
        "import torch\n",
        "import numpy as np\n",
        "import torchmetrics\n",
        "from torchmetrics import functional as fn\n",
        "\n",
        "class Learner(nn.Module):\n",
        "\n",
        "    def __init__(self, **args):\n",
        "        \"\"\"\n",
        "        :param args:\n",
        "        \"\"\"\n",
        "        super(Learner, self).__init__()\n",
        "        \n",
        "        self.inner_print = args.get('inner_print')\n",
        "        self.inner_batch_size = args.get('inner_batch_size')\n",
        "        self.outer_update_lr  = args.get('outer_update_lr')\n",
        "        self.inner_update_lr  = args.get('inner_update_lr')\n",
        "        self.inner_update_step = args.get('inner_update_step')\n",
        "        self.inner_update_step_eval = args.get('inner_update_step_eval')\n",
        "        self.model = args.get('model')\n",
        "        self.device = args.get('device')\n",
        "        \n",
        "        # Outer optimizer\n",
        "        self.outer_optimizer = Adam(self.model.parameters(), lr=self.outer_update_lr)\n",
        "        self.model.train()\n",
        "\n",
        "    def forward(self, batch_tasks, training = True, valid_train = True):\n",
        "        \"\"\"\n",
        "        batch = [(support TensorDataset, query TensorDataset),\n",
        "                 (support TensorDataset, query TensorDataset),\n",
        "                 (support TensorDataset, query TensorDataset),\n",
        "                 (support TensorDataset, query TensorDataset)]\n",
        "        \n",
        "        # support = TensorDataset(all_input_ids, all_attention_mask, all_segment_ids, all_label_ids)\n",
        "        \"\"\"\n",
        "        task_accs = []\n",
        "        task_f1 = []\n",
        "        task_recall = []\n",
        "        sum_gradients = []\n",
        "        num_task = len(batch_tasks)\n",
        "        num_inner_update_step = self.inner_update_step if training else self.inner_update_step_eval\n",
        "\n",
        "        # Outer loop tasks \n",
        "        for task_id, task in enumerate(batch_tasks):\n",
        "            support = task[0]\n",
        "            query   = task[1]\n",
        "            name   = task[2]\n",
        "            \n",
        "            # Copying model\n",
        "            fast_model = deepcopy(self.model)\n",
        "            fast_model.to(self.device)\n",
        "            \n",
        "            # Inner trainer optimizer\n",
        "            inner_optimizer = Adam(fast_model.parameters(), lr=self.inner_update_lr)\n",
        "            \n",
        "            # Creating training data loaders\n",
        "            if len(support) % self.inner_batch_size == 1 :\n",
        "              support_dataloader = DataLoader(support, sampler=RandomSampler(support),\n",
        "                                              batch_size=self.inner_batch_size,\n",
        "                                              drop_last=True)\n",
        "            else:\n",
        "              support_dataloader = DataLoader(support, sampler=RandomSampler(support),\n",
        "                                              batch_size=self.inner_batch_size,\n",
        "                                              drop_last=False)\n",
        "                            \n",
        "            # steps_per_epoch=len(support) // self.inner_batch_size\n",
        "            # total_training_steps = steps_per_epoch * 5\n",
        "            # warmup_steps = total_training_steps // 3\n",
        "            #            \n",
        "\n",
        "            # scheduler = get_linear_schedule_with_warmup(\n",
        "            #            inner_optimizer, \n",
        "            #           num_warmup_steps=warmup_steps,\n",
        "            #           num_training_steps=total_training_steps\n",
        "            #           )\n",
        "\n",
        "            fast_model.train()            \n",
        "\n",
        "            # Inner loop training epoch (support set)\n",
        "            if valid_train:\n",
        "              print('----Task',task_id,\":\", name, '----')\n",
        "\n",
        "            for i in range(0, num_inner_update_step):\n",
        "                all_loss = []\n",
        "\n",
        "                # Inner loop training batch (support set)\n",
        "                for inner_step, batch in enumerate(support_dataloader):\n",
        "                    batch = tuple(t.to(self.device) for t in batch)\n",
        "                    input_ids, attention_mask, token_type_ids, label_id = batch\n",
        "\n",
        "                    # Feed Foward\n",
        "                    loss, _, _ = fast_model(input_ids, attention_mask, token_type_ids=token_type_ids, labels = label_id)\n",
        "                                  \n",
        "                    # Computing gradients\n",
        "                    loss.backward()\n",
        "                    # torch.nn.utils.clip_grad_norm_(fast_model.parameters(), max_norm=1)\n",
        "                    \n",
        "                    # Updating inner training parameters\n",
        "                    inner_optimizer.step()\n",
        "                    inner_optimizer.zero_grad()\n",
        "                    \n",
        "                    # Appending losses\n",
        "                    all_loss.append(loss.item())\n",
        "                    \n",
        "                    del batch, input_ids, attention_mask, label_id\n",
        "                    torch.cuda.empty_cache()\n",
        "                \n",
        "                if valid_train:\n",
        "                  if (i+1) % self.inner_print == 0:\n",
        "                      print(\"Inner Loss: \", np.mean(all_loss))\n",
        "\n",
        "            fast_model.to(torch.device('cpu'))\n",
        "            \n",
        "            # Inner training phase weights\n",
        "            if training:\n",
        "                meta_weights = list(self.model.parameters())\n",
        "                fast_weights = list(fast_model.parameters())\n",
        "\n",
        "                # Appending gradients\n",
        "                gradients = []\n",
        "                for i, (meta_params, fast_params) in enumerate(zip(meta_weights, fast_weights)):\n",
        "                    gradient = meta_params - fast_params\n",
        "                    if task_id == 0:\n",
        "                        sum_gradients.append(gradient)\n",
        "                    else:\n",
        "                        sum_gradients[i] += gradient\n",
        "\n",
        "\n",
        "            # Inner test (query set)\n",
        "            fast_model.to(self.device)\n",
        "            fast_model.eval()\n",
        "\n",
        "            if valid_train:\n",
        "              # Inner test (query set)\n",
        "              fast_model.to(self.device)\n",
        "              fast_model.eval()\n",
        "              \n",
        "            with torch.no_grad():\n",
        "                # Data loader\n",
        "                query_dataloader = DataLoader(query, sampler=None, batch_size=len(query))\n",
        "                query_batch = iter(query_dataloader).next()\n",
        "                query_batch = tuple(t.to(self.device) for t in query_batch)\n",
        "                q_input_ids, q_attention_mask, q_token_type_ids, q_label_id = query_batch\n",
        "                \n",
        "                # Feedfoward\n",
        "                _, _, pre_label_id = fast_model(q_input_ids, q_attention_mask, q_token_type_ids, labels = q_label_id)\n",
        "\n",
        "                # Predictions\n",
        "                pre_label_id = pre_label_id.detach().cpu().squeeze()\n",
        "                # Labels\n",
        "                q_label_id = q_label_id.detach().cpu()\n",
        "\n",
        "                # Calculating metrics\n",
        "                acc = fn.accuracy(pre_label_id, q_label_id).item()\n",
        "                recall = fn.recall(pre_label_id, q_label_id).item(),\n",
        "                f1 = fn.f1_score(pre_label_id, q_label_id).item()\n",
        "\n",
        "                # appending metrics\n",
        "                task_accs.append(acc)\n",
        "                task_f1.append(f1)\n",
        "                task_recall.append(recall)\n",
        "            \n",
        "                fast_model.to(torch.device('cpu'))\n",
        "\n",
        "            del fast_model, inner_optimizer\n",
        "            torch.cuda.empty_cache()\n",
        "        \n",
        "        print(\"\\n\")\n",
        "        print(\"f1:\",np.mean(task_f1))\n",
        "        print(\"recall:\",np.mean(task_recall))\n",
        "\n",
        "        # Updating outer training parameters\n",
        "        if training:\n",
        "            # Mean of gradients\n",
        "            for i in range(0,len(sum_gradients)):\n",
        "                sum_gradients[i] = sum_gradients[i] / float(num_task)\n",
        "\n",
        "            # Indexing parameters to model\n",
        "            for i, params in enumerate(self.model.parameters()):\n",
        "                params.grad = sum_gradients[i]\n",
        "\n",
        "            # Updating parameters\n",
        "            self.outer_optimizer.step()\n",
        "            self.outer_optimizer.zero_grad()\n",
        "            \n",
        "            del sum_gradients\n",
        "            gc.collect()\n",
        "            torch.cuda.empty_cache()\n",
        "\n",
        "        if valid_train:\n",
        "          return np.mean(task_accs)\n",
        "        else:\n",
        "          return np.array(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "lZIKqVG6HpoS",
      "metadata": {
        "id": "lZIKqVG6HpoS"
      },
      "source": [
        "## Task Loader\n",
        "\n",
        "Pre-process a domain task to the model\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "id": "CPY4pl1kPFMV",
      "metadata": {
        "id": "CPY4pl1kPFMV"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "\n",
        "LABEL_MAP = {'negative': 0,\n",
        "             'not included':0,\n",
        "             '0':0,\n",
        "             0:0,\n",
        "             'excluded':0,\n",
        "             'positive': 1,\n",
        "             'included':1,\n",
        "             '1':1,\n",
        "             1:1,\n",
        "             }\n",
        "\n",
        "class SLR_DataSet(Dataset):\n",
        "  def __init__(self,treat_text =None, **args):\n",
        "    self.tokenizer = args.get('tokenizer')\n",
        "    self.data = args.get('data')\n",
        "    self.max_seq_length = args.get(\"max_seq_length\", 512)\n",
        "    self.INPUT_NAME = args.get(\"input\", 'x')\n",
        "    self.LABEL_NAME = args.get(\"output\", 'y')\n",
        "    self.treat_text = treat_text\n",
        "\n",
        "  # Tokenizing and processing text\n",
        "  def encode_text(self, example):\n",
        "    comment_text = example[self.INPUT_NAME]\n",
        "    if self.treat_text:\n",
        "      comment_text = self.treat_text(comment_text)\n",
        "    \n",
        "    try:\n",
        "      labels = LABEL_MAP[example[self.LABEL_NAME].lower()]\n",
        "    except:\n",
        "      labels = -1\n",
        "\n",
        "    encoding = self.tokenizer.encode_plus(\n",
        "      (comment_text, \"It is great text\"),\n",
        "      add_special_tokens=True,\n",
        "      max_length=self.max_seq_length,\n",
        "      return_token_type_ids=True,\n",
        "      padding=\"max_length\",\n",
        "      truncation=True,\n",
        "      return_attention_mask=True,\n",
        "      return_tensors='pt',\n",
        "    )\n",
        "\n",
        "    \n",
        "    return tuple((\n",
        "      encoding[\"input_ids\"].flatten(),\n",
        "      encoding[\"attention_mask\"].flatten(),\n",
        "      encoding[\"token_type_ids\"].flatten(),\n",
        "      torch.tensor([torch.tensor(labels).to(int)])\n",
        "    ))\n",
        "  \n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.data)\n",
        "\n",
        "  # Returning data\n",
        "  def __getitem__(self, index: int):\n",
        "    # print(index)\n",
        "    data_row = self.data.reset_index().iloc[index]\n",
        "    temp_data =  self.encode_text(data_row)\n",
        "    return temp_data\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "zCzWI2YKMoks",
      "metadata": {
        "id": "zCzWI2YKMoks"
      },
      "source": [
        "## Tasks maker\n",
        "\n",
        "Builds and pre-process a bunch of task for the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "id": "tLSwhmNu0sKX",
      "metadata": {
        "id": "tLSwhmNu0sKX"
      },
      "outputs": [],
      "source": [
        "from torch.utils.data import Dataset\n",
        "from torch.utils.data import TensorDataset\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "\n",
        "# Creating Meta Tasks\n",
        "class MetaTask(Dataset):\n",
        "    def __init__(self, examples, num_task, k_support, k_query,\n",
        "                 tokenizer, training=True, max_seq_length=512,\n",
        "                 treat_text =None, **args):\n",
        "        \"\"\"\n",
        "        :param samples: list of samples\n",
        "        :param num_task: number of training tasks.\n",
        "        :param k_support: number of classes support samples per task\n",
        "        :param k_query: number of classes query sample per task\n",
        "        \"\"\"\n",
        "        self.examples = examples\n",
        "        \n",
        "        self.num_task =  num_task\n",
        "        self.k_support = k_support\n",
        "        self.k_query = k_query\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_seq_length = max_seq_length\n",
        "        self.treat_text = treat_text\n",
        "        \n",
        "        # Randomly generating tasks\n",
        "        self.create_batch(self.num_task, training)\n",
        "        \n",
        "    # Creating batch\n",
        "    def create_batch(self, num_task, training):\n",
        "        self.supports = []  # support set\n",
        "        self.queries = []  # query set\n",
        "        self.task_names = [] # Name of task\n",
        "        self.supports_indexs = [] # index of supports\n",
        "        self.queries_indexs = [] # index of queries\n",
        "        self.num_task=num_task\n",
        "        \n",
        "        # Available tasks\n",
        "        domains = self.examples['domain'].unique()\n",
        "\n",
        "        # If not training, create all tasks\n",
        "        if not(training):\n",
        "          self.task_names = domains\n",
        "          num_task = len(self.task_names)\n",
        "          self.num_task=num_task\n",
        "\n",
        "        \n",
        "        for b in range(num_task):  # For each task,\n",
        "            total_per_class = self.k_support + self.k_query \n",
        "            task_size = 2*self.k_support + 2*self.k_query \n",
        "\n",
        "            # Select a task at random\n",
        "            if training:  \n",
        "              domain = random.choice(domains)\n",
        "              self.task_names.append(domain)\n",
        "            else:\n",
        "              domain = self.task_names[b]\n",
        "\n",
        "            # Task data\n",
        "            domainExamples = self.examples[self.examples['domain'] == domain]\n",
        "\n",
        "            # Minimal label quantity\n",
        "            min_per_class = min(domainExamples['label'].value_counts())\n",
        "\n",
        "            if total_per_class > min_per_class:\n",
        "              total_per_class = min_per_class\n",
        "            \n",
        "            # Select k_support + k_query task examples\n",
        "            # Sample (n) from each label(class)\n",
        "            selected_examples = domainExamples.groupby(\"label\").sample(total_per_class, replace = False)\n",
        "\n",
        "            # Split data into support (training) and query (testing) sets\n",
        "            s, q = train_test_split(selected_examples,\n",
        "                                    stratify= selected_examples[\"label\"],\n",
        "                                    test_size= 2*self.k_query/task_size,\n",
        "                                    shuffle=True)\n",
        "            \n",
        "            # Permutating data\n",
        "            s = s.sample(frac=1)  \n",
        "            q = q.sample(frac=1) \n",
        "\n",
        "            # Appending indexes\n",
        "            if not(training):\n",
        "              self.supports_indexs.append(s.index)\n",
        "              self.queries_indexs.append(q.index)\n",
        "\n",
        "            # Creating list of support (training) and query (testing) tasks\n",
        "            self.supports.append(s.to_dict('records'))\n",
        "            self.queries.append(q.to_dict('records'))\n",
        "\n",
        "    # Creating task tensors\n",
        "    def create_feature_set(self, examples):\n",
        "        all_input_ids      = torch.empty(len(examples), self.max_seq_length, dtype = torch.long)\n",
        "        all_attention_mask = torch.empty(len(examples), self.max_seq_length, dtype = torch.long)\n",
        "        all_token_type_ids = torch.empty(len(examples), self.max_seq_length, dtype = torch.long)\n",
        "        all_label_ids      = torch.empty(len(examples), dtype = torch.long)\n",
        "\n",
        "        for _id, e in enumerate(examples):\n",
        "          all_input_ids[_id], all_attention_mask[_id], all_token_type_ids[_id], all_label_ids[_id] = self.encode_text(e)\n",
        "\n",
        "        return TensorDataset(\n",
        "            all_input_ids,\n",
        "            all_attention_mask,\n",
        "            all_token_type_ids,\n",
        "            all_label_ids\n",
        "        ) \n",
        "      \n",
        "    # Data encoding\n",
        "    def encode_text(self, example):\n",
        "      comment_text = example[\"text\"]\n",
        "\n",
        "      if self.treat_text:\n",
        "        comment_text = self.treat_text(comment_text)\n",
        "      \n",
        "      labels = LABEL_MAP[example[\"label\"]]\n",
        "\n",
        "      encoding = self.tokenizer.encode_plus(\n",
        "        (comment_text, \"It is a great text.\"),\n",
        "        add_special_tokens=True,\n",
        "        max_length=self.max_seq_length,\n",
        "        return_token_type_ids=True,\n",
        "        padding=\"max_length\",\n",
        "        truncation=True,\n",
        "        return_attention_mask=True,\n",
        "        return_tensors='pt',\n",
        "      )\n",
        "\n",
        "      return tuple((\n",
        "        encoding[\"input_ids\"].flatten(),\n",
        "        encoding[\"attention_mask\"].flatten(),\n",
        "        encoding[\"token_type_ids\"].flatten(),\n",
        "        torch.tensor([torch.tensor(labels).to(int)])\n",
        "      ))\n",
        "\n",
        "    # Returns data upon calling\n",
        "    def __getitem__(self, index):\n",
        "        support_set = self.create_feature_set(self.supports[index])\n",
        "        query_set   = self.create_feature_set(self.queries[index])\n",
        "        name        = self.task_names[index]\n",
        "        return support_set, query_set, name\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.num_task"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "v8TU8TxgEkIL",
      "metadata": {
        "id": "v8TU8TxgEkIL"
      },
      "source": [
        "# 50-50 split simulation\n",
        "\n",
        "This section explore the methodology of train the Meta-Learner - Systematic Literature Review Classifier (ML-SLRC) splitting the 64 datasets in a such way that have at least 50 Included (positive) and not Included negative examples."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3tWCZeIM2zHV",
      "metadata": {
        "id": "3tWCZeIM2zHV"
      },
      "source": [
        "### Data"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "jJwL3bIiIpIp",
      "metadata": {
        "id": "jJwL3bIiIpIp"
      },
      "source": [
        "#### Data Statistics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "H7xiljcd6DXu",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "H7xiljcd6DXu",
        "outputId": "5b0228c0-5e89-456f-f86d-b984ba7da05f"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-0fef51da-3b28-47d6-8156-6f47336b4156\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>size</th>\n",
              "      <th>pos</th>\n",
              "      <th>neg</th>\n",
              "      <th>names</th>\n",
              "      <th>paths</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>206</td>\n",
              "      <td>6</td>\n",
              "      <td>200</td>\n",
              "      <td>SR4_Li.csv</td>\n",
              "      <td>SLR_data/Screening PubMed abstracts_ is class ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>623</td>\n",
              "      <td>23</td>\n",
              "      <td>600</td>\n",
              "      <td>SR8_Liu.csv</td>\n",
              "      <td>SLR_data/Screening PubMed abstracts_ is class ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>413</td>\n",
              "      <td>13</td>\n",
              "      <td>400</td>\n",
              "      <td>SR9_Douxfils.csv</td>\n",
              "      <td>SLR_data/Screening PubMed abstracts_ is class ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>832</td>\n",
              "      <td>32</td>\n",
              "      <td>800</td>\n",
              "      <td>SR6_Wang.csv</td>\n",
              "      <td>SLR_data/Screening PubMed abstracts_ is class ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>209</td>\n",
              "      <td>9</td>\n",
              "      <td>200</td>\n",
              "      <td>SR2_Meng.csv</td>\n",
              "      <td>SLR_data/Screening PubMed abstracts_ is class ...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-0fef51da-3b28-47d6-8156-6f47336b4156')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-0fef51da-3b28-47d6-8156-6f47336b4156 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-0fef51da-3b28-47d6-8156-6f47336b4156');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "   size  pos  neg             names  \\\n",
              "0   206    6  200        SR4_Li.csv   \n",
              "1   623   23  600       SR8_Liu.csv   \n",
              "2   413   13  400  SR9_Douxfils.csv   \n",
              "3   832   32  800      SR6_Wang.csv   \n",
              "4   209    9  200      SR2_Meng.csv   \n",
              "\n",
              "                                               paths  \n",
              "0  SLR_data/Screening PubMed abstracts_ is class ...  \n",
              "1  SLR_data/Screening PubMed abstracts_ is class ...  \n",
              "2  SLR_data/Screening PubMed abstracts_ is class ...  \n",
              "3  SLR_data/Screening PubMed abstracts_ is class ...  \n",
              "4  SLR_data/Screening PubMed abstracts_ is class ...  "
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Loading descriptive statistics\n",
        "info_load = load_data_statistics(paths)\n",
        "\n",
        "info_load.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ypcWFBRNFAt7",
      "metadata": {
        "id": "ypcWFBRNFAt7"
      },
      "source": [
        "#### Data split"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "Q8_rBa87K4ke",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q8_rBa87K4ke",
        "outputId": "cc30ea97-b342-4cef-a016-d1ccc33add91"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "11                    SR10_Kourbeti.csv\n",
            "14               cereals_Future_set.csv\n",
            "15                          cereals.csv\n",
            "16                     Leafy_Greens.csv\n",
            "25    Post_intensive_care_treatment.csv\n",
            "32                        PFOS-PFOA.csv\n",
            "33                        Neuropain.csv\n",
            "35                Transgenerational.csv\n",
            "36                              BPA.csv\n",
            "39                   Nagtegaal_2019.csv\n",
            "40                      Wahono_2015.csv\n",
            "41                        Hall_2012.csv\n",
            "43          Appenzeller-Herzog_2020.csv\n",
            "44                     van_Dis_2020.csv\n",
            "45               van_de_Schoot_2017.csv\n",
            "47               Bannach-Brown_2019.csv\n",
            "48                        Kwok_2020.csv\n",
            "49             ProtonPumpInhibitors.csv\n",
            "50                    ACEInhibitors.csv\n",
            "51              UrinaryIncontinence.csv\n",
            "53                OralHypoglycemics.csv\n",
            "54                           NSAIDS.csv\n",
            "55                          Statins.csv\n",
            "56           AtypicalAntipsychotics.csv\n",
            "57                   Antihistamines.csv\n",
            "58                         Triptans.csv\n",
            "59           CalciumChannelBlockers.csv\n",
            "60                        Estrogens.csv\n",
            "61                     BetaBlockers.csv\n",
            "62                             ADHD.csv\n",
            "Name: names, dtype: object\n"
          ]
        }
      ],
      "source": [
        "# Defining selection criteria for the training dataset: datasets with over 50 positive and 50 negative labels\n",
        "select_criteria = (info_load['pos'] >= 50) & (info_load['neg'] >= 50)\n",
        "print(info_load[select_criteria]['names'] )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "id": "cgu3efPhRgMc",
      "metadata": {
        "id": "cgu3efPhRgMc"
      },
      "outputs": [],
      "source": [
        "# Defining the training dataset\n",
        "Train_resource = load_data(\n",
        "    info_load[select_criteria]\n",
        ")\n",
        "\n",
        "Train_resource = Train_resource.dropna(axis=0).reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "# Validation data\n",
        "conditional = Train_resource['domain'] == \"PFOS-PFOA.csv\"\n",
        "valid_tranf = Train_resource[conditional]\n",
        "Train_resource = Train_resource[~conditional].reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "id": "mf0-FmmVRhp8",
      "metadata": {
        "id": "mf0-FmmVRhp8"
      },
      "outputs": [],
      "source": [
        "# Selecting data with at least 40 words separated by spaces\n",
        "crit = Train_resource[\"text\"].apply(lambda x: len(x.split(\" \"))) >= 40\n",
        "Train_resource = Train_resource[crit].reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "id": "01uw7iFBU9dk",
      "metadata": {
        "id": "01uw7iFBU9dk"
      },
      "outputs": [],
      "source": [
        "# Data that doesn't fit 50pos/50neg criteria\n",
        "rest_resource = load_data(\n",
        "    info_load[~select_criteria]\n",
        ")\n",
        "\n",
        "rest_resource = pd.concat([valid_tranf, rest_resource]).reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "id": "frk2kNQgnSjy",
      "metadata": {
        "id": "frk2kNQgnSjy"
      },
      "outputs": [],
      "source": [
        "# Defining the testing dataset\n",
        "Test_resource = rest_resource[rest_resource['domain'].isin(['SR11_Li.csv',\n",
        " 'SR14_Funakoshi.csv',\n",
        " 'SR2_Meng.csv',\n",
        " 'SR6_Wang.csv',\n",
        " 'SR7_Zhou.csv',\n",
        " 'SR8_Liu.csv',\n",
        " 'SR9_Douxfils.csv',\n",
        " 'Distal_radius_fractures_approach.csv',\n",
        " 'Hallux_valgus_prognostic.csv',\n",
        " 'Head_and_neck_cancer_imaging.csv',\n",
        " 'Obstetric_emergency_training.csv',\n",
        " 'Pregnancy_medication.csv',\n",
        " 'Shoulderdystocia_positioning.csv',\n",
        " 'Shoulderdystocia_recurrence.csv',\n",
        " 'SR12_Cavender.csv',\n",
        " 'SR13_Chatterjee.csv',\n",
        " 'SR1_Yang.csv',\n",
        " 'SR3_Segelov.csv',\n",
        " 'SR4_Li.csv',\n",
        " 'SR5_Lv.csv'])]\n",
        "\n",
        "Test_resource = Test_resource.dropna(axis=0).reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "# Selecting data with at least 40 words separated by spaces\n",
        "crit = Test_resource[\"text\"].apply(lambda x: len(x.split(\" \"))) >= 40\n",
        "Test_resource = Test_resource[crit].reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "id": "BWUeVk1NU6zV",
      "metadata": {
        "id": "BWUeVk1NU6zV"
      },
      "outputs": [],
      "source": [
        "# Defining the validation dataset\n",
        "Valid_resource = rest_resource[rest_resource['domain'].isin(['PFOS-PFOA.csv',\n",
        " 'Bos_2018.csv',\n",
        " 'Wolters_2018.csv',\n",
        " 'SkeletalMuscleRelaxants.csv',\n",
        " 'Fluoride.csv',\n",
        " 'Kitchenham_2010.csv',\n",
        " 'Radjenovic_2013.csv',\n",
        " 'Opiods.csv',\n",
        " 'Leafy_Greens_Future_set.csv',\n",
        " 'Distal_radius_fractures_closed_reduction.csv',\n",
        " 'Head_and_neck_cancer_bone.csv',\n",
        " 'Shoulder_replacement_diagnostic.csv',\n",
        " 'Shoulder_replacement_surgery.csv',\n",
        " 'Total_knee_replacement.csv',\n",
        " 'Vascular_access.csv'])]\n",
        "\n",
        "Valid_resource =  Valid_resource.dropna(axis=0).reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "# Selecting data with at least 40 words separated by spaces\n",
        "crit = Valid_resource[\"text\"].apply(lambda x: len(x.split(\" \"))) >= 40\n",
        "Valid_resource = Valid_resource[crit].reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "lqDo8-v2FODY",
      "metadata": {
        "id": "lqDo8-v2FODY"
      },
      "source": [
        "### Exploratory Data Analysis\n",
        "\n",
        "Histograms of number of words separated by \" \" and count of positive and negative examples of each dataset of the resource"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Wh2XVuYGmo4v",
      "metadata": {
        "id": "Wh2XVuYGmo4v"
      },
      "source": [
        "#### Train Resource"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "id": "H1CyN8RxOlEG",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "H1CyN8RxOlEG",
        "outputId": "a13e7879-7441-46ea-99ec-262e9e0d3a6f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "Train_resource[\"text\"].apply(lambda x: len(x.split(\" \"))).hist()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "26iDqWZp7kFC",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "26iDqWZp7kFC",
        "outputId": "2dcdac6b-aae6-4e57-ad39-bb8ae4c4a5f8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "domain                             label   \n",
              "ACEInhibitors.csv                  negative     2041\n",
              "                                   positive      166\n",
              "ADHD.csv                           negative      701\n",
              "                                   positive       80\n",
              "Antihistamines.csv                 negative      190\n",
              "                                   positive       87\n",
              "Appenzeller-Herzog_2020.csv        negative     2182\n",
              "                                   positive      161\n",
              "AtypicalAntipsychotics.csv         negative      670\n",
              "                                   positive      329\n",
              "BPA.csv                            negative     6980\n",
              "                                   positive      101\n",
              "Bannach-Brown_2019.csv             negative     1347\n",
              "                                   positive      251\n",
              "BetaBlockers.csv                   negative     1552\n",
              "                                   positive      267\n",
              "CalciumChannelBlockers.csv         negative      824\n",
              "                                   positive      246\n",
              "Estrogens.csv                      negative      260\n",
              "                                   positive       77\n",
              "Hall_2012.csv                      negative     8773\n",
              "                                   positive      104\n",
              "Kwok_2020.csv                      negative     2192\n",
              "                                   positive      114\n",
              "Leafy_Greens.csv                   negative      158\n",
              "                                   positive       66\n",
              "NSAIDS.csv                         negative      267\n",
              "                                   positive       81\n",
              "Nagtegaal_2019.csv                 negative     1463\n",
              "                                   positive      383\n",
              "Neuropain.csv                      negative    24175\n",
              "                                   positive     5005\n",
              "OralHypoglycemics.csv              negative      328\n",
              "                                   positive      134\n",
              "Post_intensive_care_treatment.csv  negative      282\n",
              "                                   positive       96\n",
              "ProtonPumpInhibitors.csv           negative      950\n",
              "                                   positive      220\n",
              "SR10_Kourbeti.csv                  negative     1600\n",
              "                                   positive       75\n",
              "Statins.csv                        negative     2502\n",
              "                                   positive      150\n",
              "Transgenerational.csv              negative    45406\n",
              "                                   positive      606\n",
              "Triptans.csv                       negative      371\n",
              "                                   positive      200\n",
              "UrinaryIncontinence.csv            negative      206\n",
              "                                   positive       65\n",
              "Wahono_2015.csv                    negative     6930\n",
              "                                   positive       62\n",
              "cereals.csv                        negative      382\n",
              "                                   positive      292\n",
              "cereals_Future_set.csv             negative       76\n",
              "                                   positive       71\n",
              "van_Dis_2020.csv                   negative     9738\n",
              "                                   positive      769\n",
              "van_de_Schoot_2017.csv             negative     5065\n",
              "                                   positive      359\n",
              "Name: label, dtype: int64"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Train_resource.groupby('domain')['label']\\\n",
        "              .value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9SYTNYLQqWPG",
      "metadata": {
        "id": "9SYTNYLQqWPG"
      },
      "source": [
        "#### Test Resource"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "id": "a-aR0DKVOtLm",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "a-aR0DKVOtLm",
        "outputId": "08139fd9-cc72-4af8-bfbf-d91c9e4a158e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAXHElEQVR4nO3db4xcV33G8e+DnT8uobED6ci1rdoIt5XBwklXiRF9MSTFcQzCqZQiRxZxgtG2kqOGdvvHpi9SSC0FCeMSFaJuscFQinEDNCvHbWqcjBAvkjgpbvyP4CUxtVdO3GLHsKWNuuHXF3NmmZhdz+zs7OzeOc9HGu29v3PuzD0+1jN37tyZUURgZmZ5eMN074CZmXWOQ9/MLCMOfTOzjDj0zcwy4tA3M8uIQ9/MLCNNh76kWZK+K2lvWl8i6SlJg5K+JunyVL8irQ+m9sV197El1Z+XdEvbR2NmZpc0kSP9e4HjdeufBLZHxNuA88DGVN8InE/17akfkpYB64C3A6uBz0maNbndNzOziWgq9CUtBN4HfD6tC7gJeDh12QXclpbXpnVS+82p/1pgd0S8GhEvAoPADW0Yg5mZNWl2k/3+Gvgz4E1p/c3AKxExktZPAwvS8gLgFEBEjEi6kPovAJ6su8/6bUZJ6gV6AebMmfNbixYtGm372c9+xhve0L1vQ3h8xebxFVs3je/73//+f0XEtWO1NQx9Se8HzkbEs5LKbd63XxAR/UA/QE9PTzzzzDOjbZVKhXJ5yndh2nh8xebxFVs3jU/SD8dra+ZI/93AByStAa4Efhn4DDBX0ux0tL8QGEr9h4BFwGlJs4GrgR/V1WvqtzEzsw5o+FomIrZExMKIWEz1jdjHI2I98ARwe+q2AXgkLQ+kdVL741H9VrcBYF26umcJsBR4um0jMTOzhpo9pz+WPwd2S/or4LvAjlTfAXxZ0iBwjuoTBRFxVNIe4BgwAmyKiNcm8fhmZjZBEwr9iKgAlbT8AmNcfRMR/wv83jjbbwW2TnQnzcysPbrjrWozM2uKQ9/MLCMOfTOzjDj0zcwy4tA3M8vIZC7ZtHEs3vxoS9v1LR/hrha3rTn5wPsmtb2ZdTcf6ZuZZcShb2aWEYe+mVlGHPpmZhlx6JuZZcShb2aWEYe+mVlGHPpmZhlx6JuZZcShb2aWEYe+mVlGHPpmZhlpGPqSrpT0tKR/l3RU0sdT/YuSXpR0KN1WpLokPShpUNJzkq6vu68Nkk6k24ZxHtLMzKZIM9+y+SpwU0QMS7oM+I6kf05tfxoRD1/U/1ZgabrdCDwE3CjpGuA+oAcI4FlJAxFxvh0DMTOzxhoe6UfVcFq9LN3iEpusBb6UtnsSmCtpPnALsD8izqWg3w+sntzum5nZRDR1Tl/SLEmHgLNUg/up1LQ1ncLZLumKVFsAnKrb/HSqjVc3M7MOaepHVCLiNWCFpLnANyW9A9gCvARcDvQDfw58YrI7JKkX6AUolUpUKpXRtuHh4detz1R9y0da2q40p/Vta2byv09R5q9VHl+xdfv4aib0y1kR8YqkJ4DVEfGpVH5V0heAP0nrQ8Cius0WptoQUL6oXhnjMfqpPonQ09MT5fLPN6lUKtSvz1St/vpV3/IRth2e3I+ZnVxfntT2U6ko89cqj6/Yun18Nc1cvXNtOsJH0hzgvcD30nl6JAm4DTiSNhkA7kxX8awELkTEGeAxYJWkeZLmAatSzczMOqSZw8r5wC5Js6g+SeyJiL2SHpd0LSDgEPAHqf8+YA0wCPwUuBsgIs5Juh84mPp9IiLOtW0kZmbWUMPQj4jngOvGqN80Tv8ANo3TthPYOcF9NDOzNvEncs3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMuLQNzPLiEPfzCwjDUNf0pWSnpb075KOSvp4qi+R9JSkQUlfk3R5ql+R1gdT++K6+9qS6s9LumXKRmVmZmNq5kj/VeCmiHgnsAJYLWkl8Elge0S8DTgPbEz9NwLnU3176oekZcA64O3AauBzkma1cSxmZtZAw9CPquG0elm6BXAT8HCq7wJuS8tr0zqp/WZJSvXdEfFqRLwIDAI3tGMQZmbWnNnNdEpH5M8CbwM+C/wAeCUiRlKX08CCtLwAOAUQESOSLgBvTvUn6+62fpv6x+oFegFKpRKVSmW0bXh4+HXrM1Xf8pHGncZQmtP6tjUz+d+nKPPXKo+v2Lp9fDVNhX5EvAaskDQX+Cbwm1O1QxHRD/QD9PT0RLlcHm2rVCrUr89Ud21+tKXt+paPsO1wU1MyrpPry5PafioVZf5a5fEVW7ePr2ZCV+9ExCvAE8C7gLmSagm1EBhKy0PAIoDUfjXwo/r6GNuYmVkHNHP1zrXpCB9Jc4D3Asephv/tqdsG4JG0PJDWSe2PR0Sk+rp0dc8SYCnwdJvGYWZmTWjmXMJ8YFc6r/8GYE9E7JV0DNgt6a+A7wI7Uv8dwJclDQLnqF6xQ0QclbQHOAaMAJvSaSMzM+uQhqEfEc8B141Rf4Exrr6JiP8Ffm+c+9oKbJ34bpqZWTv4E7lmZhmZ3KUiNuMsbvHKock6+cD7puVxzWxifKRvZpYRh76ZWUYc+mZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llpJkfRl8k6QlJxyQdlXRvqv+lpCFJh9JtTd02WyQNSnpe0i119dWpNihp89QMyczMxtPML2eNAH0R8W+S3gQ8K2l/atseEZ+q7yxpGdUfQ3878KvAtyT9emr+LPBe4DRwUNJARBxrx0DMzKyxZn4Y/QxwJi3/RNJxYMElNlkL7I6IV4EXJQ3y8x9QH0w/qI6k3amvQ9/MrEMUEc13lhYD3wbeAfwxcBfwY+AZqq8Gzkv6G+DJiPj7tM0O4J/TXayOiI+k+oeAGyPinoseoxfoBSiVSr+1e/fu0bbh4WGuuuqqiY+yww4PXWhpu9IcePl/2rwzHbJ8wdUN+xRl/lrl8RVbN43vPe95z7MR0TNWW9M/jC7pKuDrwEcj4seSHgLuByL93QZ8eLI7GxH9QD9AT09PlMvl0bZKpUL9+kx1V4s/Tt63fIRth4v5W/Un15cb9inK/LXK4yu2bh9fTVMJI+kyqoH/lYj4BkBEvFzX/nfA3rQ6BCyq23xhqnGJupmZdUAzV+8I2AEcj4hP19Xn13X7XeBIWh4A1km6QtISYCnwNHAQWCppiaTLqb7ZO9CeYZiZWTOaOdJ/N/Ah4LCkQ6n2MeAOSSuont45Cfw+QEQclbSH6hu0I8CmiHgNQNI9wGPALGBnRBxt20jMzKyhZq7e+Q6gMZr2XWKbrcDWMer7LrWdmZlNLX8i18wsIw59M7OMOPTNzDLi0Dczy4hD38wsIw59M7OMOPTNzDLi0Dczy4hD38wsIw59M7OMOPTNzDLi0Dczy4hD38wsIw59M7OMOPTNzDLi0Dczy4hD38wsIw59M7OMNPPD6IskPSHpmKSjku5N9Wsk7Zd0Iv2dl+qS9KCkQUnPSbq+7r42pP4nJG2YumGZmdlYmjnSHwH6ImIZsBLYJGkZsBk4EBFLgQNpHeBWYGm69QIPQfVJArgPuBG4Abiv9kRhZmad0TD0I+JMRPxbWv4JcBxYAKwFdqVuu4Db0vJa4EtR9SQwV9J84BZgf0Sci4jzwH5gdTsHY2ZmlzZ7Ip0lLQauA54CShFxJjW9BJTS8gLgVN1mp1NtvPrFj9FL9RUCpVKJSqUy2jY8PPy69Zmqb/lIS9uV5rS+7XRrZl6KMn+t8viKrdvHV9N06Eu6Cvg68NGI+LGk0baICEnRjh2KiH6gH6CnpyfK5fJoW6VSoX59prpr86Mtbde3fIRthyf0PDxjnFxfbtinKPPXKo+v2Lp9fDVNXb0j6TKqgf+ViPhGKr+cTtuQ/p5N9SFgUd3mC1NtvLqZmXVIM1fvCNgBHI+IT9c1DQC1K3A2AI/U1e9MV/GsBC6k00CPAaskzUtv4K5KNTMz65BmziW8G/gQcFjSoVT7GPAAsEfSRuCHwAdT2z5gDTAI/BS4GyAizkm6HziY+n0iIs61YxBmZtachqEfEd8BNE7zzWP0D2DTOPe1E9g5kR00M7P28Sdyzcwy4tA3M8uIQ9/MLCMOfTOzjDj0zcwy4tA3M8uIQ9/MLCMOfTOzjDj0zcwy4tA3M8uIQ9/MLCMOfTOzjDj0zcwy4tA3M8uIQ9/MLCMOfTOzjDj0zcwy4tA3M8tIMz+MvlPSWUlH6mp/KWlI0qF0W1PXtkXSoKTnJd1SV1+daoOSNrd/KGZm1kgzR/pfBFaPUd8eESvSbR+ApGXAOuDtaZvPSZolaRbwWeBWYBlwR+prZmYd1MwPo39b0uIm728tsDsiXgVelDQI3JDaBiPiBQBJu1PfYxPfZTMza1XD0L+EeyTdCTwD9EXEeWAB8GRdn9OpBnDqovqNY92ppF6gF6BUKlGpVEbbhoeHX7c+U/UtH2lpu9Kc1redbs3MS1Hmr1UeX7F1+/hqWg39h4D7gUh/twEfbscORUQ/0A/Q09MT5XJ5tK1SqVC/PlPdtfnRlrbrWz7CtsOTeR6ePifXlxv2Kcr8tcrjK7ZuH19NSwkTES/XliX9HbA3rQ4Bi+q6Lkw1LlE3M7MOaemSTUnz61Z/F6hd2TMArJN0haQlwFLgaeAgsFTSEkmXU32zd6D13TYzs1Y0PNKX9FWgDLxF0mngPqAsaQXV0zsngd8HiIijkvZQfYN2BNgUEa+l+7kHeAyYBeyMiKPtHoyZmV1aM1fv3DFGeccl+m8Fto5R3wfsm9DemZlZW/kTuWZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llxKFvZpYRh76ZWUYc+mZmGXHom5llpGHoS9op6aykI3W1ayTtl3Qi/Z2X6pL0oKRBSc9Jur5umw2p/wlJG6ZmOGZmdinNHOl/EVh9UW0zcCAilgIH0jrArcDSdOsFHoLqkwTVH1S/EbgBuK/2RGFmZp3TMPQj4tvAuYvKa4FdaXkXcFtd/UtR9SQwV9J84BZgf0Sci4jzwH5+8YnEzMym2OwWtytFxJm0/BJQSssLgFN1/U6n2nj1XyCpl+qrBEqlEpVKZbRteHj4deszVd/ykZa2K81pfdvp1sy8FGX+WuXxFVu3j6+m1dAfFREhKdqxM+n++oF+gJ6eniiXy6NtlUqF+vWZ6q7Nj7a0Xd/yEbYdnvSUTIuT68sN+xRl/lrl8RVbt4+vptWrd15Op21If8+m+hCwqK7fwlQbr25mZh3UaugPALUrcDYAj9TV70xX8awELqTTQI8BqyTNS2/grko1MzProIbnEiR9FSgDb5F0mupVOA8AeyRtBH4IfDB13wesAQaBnwJ3A0TEOUn3AwdTv09ExMVvDpuZ2RRrGPoRccc4TTeP0TeATePcz05g54T2zszM2sqfyDUzy4hD38wsIw59M7OMOPTNzDLi0Dczy4hD38wsI8X8zH+TFrf4dQhmZt3KR/pmZhlx6JuZZcShb2aWEYe+mVlGHPpmZhlx6JuZZcShb2aWEYe+mVlGHPpmZhlx6JuZZcShb2aWkUmFvqSTkg5LOiTpmVS7RtJ+SSfS33mpLkkPShqU9Jyk69sxADMza147jvTfExErIqInrW8GDkTEUuBAWge4FViabr3AQ214bDMzm4CpOL2zFtiVlncBt9XVvxRVTwJzJc2fgsc3M7NxTDb0A/hXSc9K6k21UkScScsvAaW0vAA4Vbft6VQzM7MOmez36f92RAxJ+hVgv6Tv1TdGREiKidxhevLoBSiVSlQqldG24eHh16030rd8ZCIPPe1Kc4q3zzXNzMtE569oPL5i6/bx1Uwq9CNiKP09K+mbwA3Ay5LmR8SZdPrmbOo+BCyq23xhql18n/1AP0BPT0+Uy+XRtkqlQv16I3cV7EdU+paPsO1wMX/X5uT6csM+E52/ovH4iq3bx1fT8ukdSW+U9KbaMrAKOAIMABtStw3AI2l5ALgzXcWzErhQdxrIzMw6YDKHlSXgm5Jq9/MPEfEvkg4CeyRtBH4IfDD13wesAQaBnwJ3T+KxzcysBS2HfkS8ALxzjPqPgJvHqAewqdXHMzOzyfMncs3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMuLQNzPLiEPfzCwjDn0zs4wU88vbbcZZ3MRvF/QtH2n7bxycfOB9bb0/s27nI30zs4w49M3MMuLQNzPLiEPfzCwjDn0zs4w49M3MMtLx0Je0WtLzkgYlbe7045uZ5ayj1+lLmgV8FngvcBo4KGkgIo51cj+sezTz+YCp4s8IWBF1+sNZNwCDEfECgKTdwFrAoW+Fc/ETzlR8+GwsfrKxyVBEdO7BpNuB1RHxkbT+IeDGiLinrk8v0JtWfwN4vu4u3gL8V4d2dzp4fMXm8RVbN43v1yLi2rEaZtzXMEREP9A/VpukZyKip8O71DEeX7F5fMXW7eOr6fQbuUPAorr1halmZmYd0OnQPwgslbRE0uXAOmCgw/tgZpatjp7eiYgRSfcAjwGzgJ0RcXQCdzHmaZ8u4vEVm8dXbN0+PqDDb+Samdn08idyzcwy4tA3M8tIYUK/G76+QdIiSU9IOibpqKR7U/0aSfslnUh/56W6JD2YxvycpOundwTNkTRL0ncl7U3rSyQ9lcbxtfQmPpKuSOuDqX3xtO54EyTNlfSwpO9JOi7pXd00f5L+KP3fPCLpq5KuLPL8Sdop6aykI3W1Cc+XpA2p/wlJG6ZjLO1SiNCv+/qGW4FlwB2Slk3vXrVkBOiLiGXASmBTGsdm4EBELAUOpHWojndpuvUCD3V+l1tyL3C8bv2TwPaIeBtwHtiY6huB86m+PfWb6T4D/EtE/CbwTqrj7Ir5k7QA+EOgJyLeQfVii3UUe/6+CKy+qDah+ZJ0DXAfcCPVbxW4r/ZEUUgRMeNvwLuAx+rWtwBbpnu/2jCuR6h+D9HzwPxUmw88n5b/Frijrv9ov5l6o/rZiwPATcBeQFQ/5Tj74rmkehXXu9Ly7NRP0z2GS4ztauDFi/exW+YPWACcAq5J87EXuKXo8wcsBo60Ol/AHcDf1tVf169ot0Ic6fPz/4w1p1OtsNJL4euAp4BSRJxJTS8BpbRcxHH/NfBnwM/S+puBVyJiJK3Xj2F0fKn9Quo/Uy0B/hP4Qjp99XlJb6RL5i8ihoBPAf8BnKE6H8/SPfNXM9H5KtQ8NlKU0O8qkq4Cvg58NCJ+XN8W1UOJQl5HK+n9wNmIeHa692WKzAauBx6KiOuA/+bnpwaAws/fPKpfgLgE+FXgjfziqZGuUuT5alVRQr9rvr5B0mVUA/8rEfGNVH5Z0vzUPh84m+pFG/e7gQ9IOgnspnqK5zPAXEm1DwLWj2F0fKn9auBHndzhCToNnI6Ip9L6w1SfBLpl/n4HeDEi/jMi/g/4BtU57Zb5q5nofBVtHi+pKKHfFV/fIEnADuB4RHy6rmkAqF0RsIHquf5a/c50VcFK4ELdy9IZJyK2RMTCiFhMdY4ej4j1wBPA7anbxeOrjfv21H/GHnVFxEvAKUm/kUo3U/1a8K6YP6qndVZK+qX0f7U2vq6YvzoTna/HgFWS5qVXQ6tSrZim+02FZm/AGuD7wA+Av5ju/WlxDL9N9aXkc8ChdFtD9TzoAeAE8C3gmtRfVK9a+gFwmOpVFdM+jibHWgb2puW3Ak8Dg8A/Alek+pVpfTC1v3W697uJca0Anklz+E/AvG6aP+DjwPeAI8CXgSuKPH/AV6m+P/F/VF+pbWxlvoAPp3EOAndP97gmc/PXMJiZZaQop3fMzKwNHPpmZhlx6JuZZcShb2aWEYe+mVlGHPpmZhlx6JuZZeT/Adhy8NgTv5FsAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "Test_resource[\"text\"].apply(lambda x: len(x.split(\" \"))).hist()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "id": "DhitaMNdmMiE",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DhitaMNdmMiE",
        "outputId": "b6c2a048-c845-4921-998a-4b92dbf14594"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "domain                                label   \n",
              "Distal_radius_fractures_approach.csv  negative     170\n",
              "                                      positive      10\n",
              "Hallux_valgus_prognostic.csv          negative     595\n",
              "                                      positive      19\n",
              "Head_and_neck_cancer_imaging.csv      negative      38\n",
              "                                      positive      18\n",
              "Obstetric_emergency_training.csv      negative     152\n",
              "                                      positive      18\n",
              "Pregnancy_medication.csv              negative     337\n",
              "                                      positive      40\n",
              "SR11_Li.csv                           negative     200\n",
              "                                      positive       9\n",
              "SR12_Cavender.csv                     negative     400\n",
              "                                      positive      14\n",
              "SR13_Chatterjee.csv                   negative     400\n",
              "                                      positive      18\n",
              "SR14_Funakoshi.csv                    negative    1000\n",
              "                                      positive      43\n",
              "SR1_Yang.csv                          negative     400\n",
              "                                      positive      16\n",
              "SR2_Meng.csv                          negative     200\n",
              "                                      positive       9\n",
              "SR3_Segelov.csv                       negative     400\n",
              "                                      positive      13\n",
              "SR4_Li.csv                            negative     200\n",
              "                                      positive       6\n",
              "SR5_Lv.csv                            negative     400\n",
              "                                      positive      12\n",
              "SR6_Wang.csv                          negative     800\n",
              "                                      positive      32\n",
              "SR7_Zhou.csv                          negative     200\n",
              "                                      positive       9\n",
              "SR8_Liu.csv                           negative     600\n",
              "                                      positive      23\n",
              "SR9_Douxfils.csv                      negative     400\n",
              "                                      positive      13\n",
              "Shoulderdystocia_positioning.csv      negative     197\n",
              "                                      positive       6\n",
              "Shoulderdystocia_recurrence.csv       negative     291\n",
              "                                      positive       5\n",
              "Name: label, dtype: int64"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Test_resource.groupby('domain')['label']\\\n",
        "              .value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4S0AvO8AqjV3",
      "metadata": {
        "id": "4S0AvO8AqjV3"
      },
      "source": [
        "#### Validation Resource"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "id": "zKHgSV2wO291",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "zKHgSV2wO291",
        "outputId": "924cdc96-6ad3-4c2d-aa7e-ef689ae935e3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "Valid_resource[\"text\"].apply(lambda x: len(x.split(\" \"))).hist()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "id": "_iCLwIZ9mMxf",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_iCLwIZ9mMxf",
        "outputId": "0fa6187a-bb00-4907-eca7-b8dc40ca6667"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "domain                                        label   \n",
              "Bos_2018.csv                                  negative    5593\n",
              "                                              positive      11\n",
              "Distal_radius_fractures_closed_reduction.csv  negative     244\n",
              "                                              positive       6\n",
              "Fluoride.csv                                  negative    3813\n",
              "                                              positive      49\n",
              "Head_and_neck_cancer_bone.csv                 negative     266\n",
              "                                              positive      32\n",
              "Kitchenham_2010.csv                           negative    1631\n",
              "                                              positive      45\n",
              "Leafy_Greens_Future_set.csv                   positive      62\n",
              "                                              negative      32\n",
              "Opiods.csv                                    negative    1675\n",
              "                                              positive      41\n",
              "PFOS-PFOA.csv                                 negative    5831\n",
              "                                              positive      95\n",
              "Radjenovic_2013.csv                           negative    5914\n",
              "                                              positive      47\n",
              "Shoulder_replacement_diagnostic.csv           negative     318\n",
              "                                              positive       3\n",
              "Shoulder_replacement_surgery.csv              negative     360\n",
              "                                              positive       6\n",
              "SkeletalMuscleRelaxants.csv                   negative    1279\n",
              "                                              positive      26\n",
              "Total_knee_replacement.csv                    negative     417\n",
              "                                              positive      32\n",
              "Vascular_access.csv                           negative     688\n",
              "                                              positive      19\n",
              "Wolters_2018.csv                              negative    4188\n",
              "                                              positive      19\n",
              "Name: label, dtype: int64"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Valid_resource.groupby('domain')['label']\\\n",
        "              .value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e0nquuSXdL40",
      "metadata": {
        "id": "e0nquuSXdL40"
      },
      "source": [
        "## Meta learning phase"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "id": "4LK6jCM4eNiu",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4LK6jCM4eNiu",
        "outputId": "9686b2b4-055d-4721-c41f-aef8a7c6e34e"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\rMeta epoch :   0%|                                        | 0/5 [00:00<?, ?it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "-----------------Training Mode Meta_epoch: 0 -----------------\n",
            "\n",
            "----Task 0 : Wahono_2015.csv ----\n",
            "Inner Loss:  1.196001946926117\n",
            "Inner Loss:  1.0354601591825485\n",
            "----Task 1 : ADHD.csv ----\n",
            "Inner Loss:  1.1327149718999863\n",
            "Inner Loss:  0.5819268077611923\n",
            "\n",
            "\n",
            "f1: 0.7708333432674408\n",
            "recall: 0.8125\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\rMeta epoch :  20%|██████▍                         | 1/5 [00:17<01:11, 17.82s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Step: 0 \ttraining Acc: 0.75\n",
            "\n",
            "-----------------Training Mode Meta_epoch: 1 -----------------\n",
            "\n",
            "----Task 0 : CalciumChannelBlockers.csv ----\n",
            "Inner Loss:  1.1306694447994232\n",
            "Inner Loss:  0.8170998394489288\n",
            "----Task 1 : Antihistamines.csv ----\n",
            "Inner Loss:  1.1218105405569077\n",
            "Inner Loss:  0.7896986156702042\n",
            "\n",
            "\n",
            "f1: 0.6335404217243195\n",
            "recall: 0.875\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\rMeta epoch :  40%|████████████▊                   | 2/5 [00:22<00:30, 10.20s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Step: 0 \ttraining Acc: 0.5\n",
            "\n",
            "-----------------Training Mode Meta_epoch: 2 -----------------\n",
            "\n",
            "----Task 0 : NSAIDS.csv ----\n",
            "Inner Loss:  1.1956256479024887\n",
            "Inner Loss:  1.050292730331421\n",
            "----Task 1 : Leafy_Greens.csv ----\n",
            "Inner Loss:  1.0169450640678406\n",
            "Inner Loss:  0.7145338878035545\n",
            "\n",
            "\n",
            "f1: 0.619047611951828\n",
            "recall: 0.625\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\rMeta epoch :  60%|███████████████████▏            | 3/5 [00:27<00:15,  7.77s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Step: 0 \ttraining Acc: 0.625\n",
            "\n",
            "-----------------Training Mode Meta_epoch: 3 -----------------\n",
            "\n",
            "----Task 0 : Kwok_2020.csv ----\n",
            "Inner Loss:  1.1574273258447647\n",
            "Inner Loss:  0.879822388291359\n",
            "----Task 1 : BetaBlockers.csv ----\n",
            "Inner Loss:  1.149358093738556\n",
            "Inner Loss:  0.9481613487005234\n",
            "\n",
            "\n",
            "f1: 0.3333333432674408\n",
            "recall: 0.5\n",
            "Step: 0 \ttraining Acc: 0.5\n",
            "\n",
            "-----------------Testing Mode-----------------\n",
            "\n",
            "----Task 0 : SR4_Li.csv ----\n",
            "Inner Loss:  1.218211591243744\n",
            "Inner Loss:  1.1553956866264343\n",
            "\n",
            "\n",
            "f1: 0.6666666865348816\n",
            "recall: 1.0\n",
            "----Task 0 : SR8_Liu.csv ----\n",
            "Inner Loss:  0.908290433883667\n",
            "Inner Loss:  0.5176807880401612\n",
            "\n",
            "\n",
            "f1: 0.9473683834075928\n",
            "recall: 0.8999999761581421\n",
            "----Task 0 : SR9_Douxfils.csv ----\n",
            "Inner Loss:  1.009125789006551\n",
            "Inner Loss:  0.5130249659220377\n",
            "\n",
            "\n",
            "f1: 0.8235293626785278\n",
            "recall: 1.0\n",
            "----Task 0 : SR6_Wang.csv ----\n",
            "Inner Loss:  0.8053878307342529\n",
            "Inner Loss:  0.8357309222221374\n",
            "\n",
            "\n",
            "f1: 0.9523809552192688\n",
            "recall: 1.0\n",
            "----Task 0 : SR2_Meng.csv ----\n",
            "Inner Loss:  1.0176585912704468\n",
            "Inner Loss:  0.8284353017807007\n",
            "\n",
            "\n",
            "f1: 0.6153846383094788\n",
            "recall: 1.0\n",
            "----Task 0 : SR13_Chatterjee.csv ----\n",
            "Inner Loss:  1.0030700445175171\n",
            "Inner Loss:  0.6515866100788117\n",
            "\n",
            "\n",
            "f1: 1.0\n",
            "recall: 1.0\n",
            "----Task 0 : SR14_Funakoshi.csv ----\n",
            "Inner Loss:  0.9013079524040222\n",
            "Inner Loss:  0.6056281000375747\n",
            "\n",
            "\n",
            "f1: 0.8695651888847351\n",
            "recall: 1.0\n",
            "----Task 0 : SR3_Segelov.csv ----\n",
            "Inner Loss:  0.8112804094950358\n",
            "Inner Loss:  0.5332788825035095\n",
            "\n",
            "\n",
            "f1: 0.875\n",
            "recall: 1.0\n",
            "----Task 0 : SR11_Li.csv ----\n",
            "Inner Loss:  1.1737160086631775\n",
            "Inner Loss:  0.7534916996955872\n",
            "\n",
            "\n",
            "f1: 0.6153846383094788\n",
            "recall: 1.0\n",
            "----Task 0 : SR5_Lv.csv ----\n",
            "Inner Loss:  1.1229622562726338\n",
            "Inner Loss:  0.6680732568105062\n",
            "\n",
            "\n",
            "f1: 0.800000011920929\n",
            "recall: 1.0\n",
            "----Task 0 : SR12_Cavender.csv ----\n",
            "Inner Loss:  0.8241571187973022\n",
            "Inner Loss:  0.42561038583517075\n",
            "\n",
            "\n",
            "f1: 0.9333333373069763\n",
            "recall: 1.0\n",
            "----Task 0 : SR1_Yang.csv ----\n",
            "Inner Loss:  1.0093792825937271\n",
            "Inner Loss:  0.6931827366352081\n",
            "\n",
            "\n",
            "f1: 0.8421052694320679\n",
            "recall: 1.0\n",
            "----Task 0 : SR7_Zhou.csv ----\n",
            "Inner Loss:  1.0154464840888977\n",
            "Inner Loss:  0.954098105430603\n",
            "\n",
            "\n",
            "f1: 0.800000011920929\n",
            "recall: 1.0\n",
            "----Task 0 : Obstetric_emergency_training.csv ----\n",
            "Inner Loss:  0.9559969425201416\n",
            "Inner Loss:  0.8821175456047058\n",
            "\n",
            "\n",
            "f1: 0.800000011920929\n",
            "recall: 0.8888888955116272\n",
            "----Task 0 : Pregnancy_medication.csv ----\n",
            "Inner Loss:  0.8073206305503845\n",
            "Inner Loss:  0.704339325428009\n",
            "\n",
            "\n",
            "f1: 0.782608687877655\n",
            "recall: 0.8999999761581421\n",
            "----Task 0 : Shoulderdystocia_positioning.csv ----\n",
            "Inner Loss:  1.330986499786377\n",
            "Inner Loss:  1.0192618370056152\n",
            "\n",
            "\n",
            "f1: 0.6666666865348816\n",
            "recall: 1.0\n",
            "----Task 0 : Head_and_neck_cancer_imaging.csv ----\n",
            "Inner Loss:  1.1329542994499207\n",
            "Inner Loss:  0.961114501953125\n",
            "\n",
            "\n",
            "f1: 0.8571428656578064\n",
            "recall: 1.0\n",
            "----Task 0 : Distal_radius_fractures_approach.csv ----\n",
            "Inner Loss:  1.0936845342318218\n",
            "Inner Loss:  1.1570686896642048\n",
            "\n",
            "\n",
            "f1: 0.7142857313156128\n",
            "recall: 1.0\n",
            "----Task 0 : Shoulderdystocia_recurrence.csv ----\n",
            "Inner Loss:  1.2707500457763672\n",
            "Inner Loss:  0.9324311017990112\n",
            "\n",
            "\n",
            "f1: 0.0\n",
            "recall: 0.0\n",
            "----Task 0 : Hallux_valgus_prognostic.csv ----\n",
            "Inner Loss:  1.0956802129745484\n",
            "Inner Loss:  0.7880972862243653\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\rMeta epoch :  80%|█████████████████████████▌      | 4/5 [01:04<00:19, 19.34s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "f1: 0.625\n",
            "recall: 0.5\n",
            "Test acc: 0.7284222200512886\n",
            "\n",
            "-----------------Training Mode Meta_epoch: 4 -----------------\n",
            "\n",
            "----Task 0 : UrinaryIncontinence.csv ----\n",
            "Inner Loss:  1.2150991261005402\n",
            "Inner Loss:  0.9470872730016708\n",
            "----Task 1 : BPA.csv ----\n",
            "Inner Loss:  1.0115374475717545\n",
            "Inner Loss:  0.6384441927075386\n",
            "\n",
            "\n",
            "f1: 0.761904776096344\n",
            "recall: 0.75\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Meta epoch : 100%|████████████████████████████████| 5/5 [01:09<00:00, 13.82s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Step: 0 \ttraining Acc: 0.75\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Meta-Training informations\n",
        "Info = {\n",
        "    \"inner_print\": 2, \n",
        "    \"bert_layers\": 2,\n",
        "    \"tokenizer\": initializer_model.tokenizer,\n",
        "    \"max_seq_length\": 512,\n",
        "    \"meta_epoch\":5, # Outer loop epochs\n",
        "    \"k_spt\":8, # Support (training) examples per class, binary case\n",
        "    \"k_qry\":8, # Query (testing) examples per class, binary case\n",
        "    \"outer_batch_size\": 5, # Size of batch of tasks\n",
        "    \"inner_batch_size\": 4, # Size of batch of classifications\n",
        "    \"outer_update_lr\" : 5e-5, # Learning rate of task optimizer\n",
        "    \"inner_update_lr\" : 5e-5, # Learning rate of classification optimizer\n",
        "    \"inner_update_step\" : 4, # Inner loop epochs\n",
        "    \"inner_update_step_eval\": 4, # Validation inner loop epochs\n",
        "    \"num_task_train\" : 2, # Number of training tasks\n",
        "    # \"num_task_test\" : 5 # Number of testing tasks\n",
        "    \"pos_weight\" : 3 # p > 1 increases recall, p < 1 increases precision, applied in loss function\n",
        "}\n",
        "\n",
        "# SLR classifier model\n",
        "model = SLR_Classifier(bert_layers = range(Info[\"bert_layers\"]),\n",
        "                       model = initializer_model.model.bert,\n",
        "                       drop=0.2)\n",
        "\n",
        "# Train the model\n",
        "meta_train(data = Train_resource,\n",
        "          model = model,\n",
        "          device = device,\n",
        "          Info = Info,\n",
        "          print_epoch =True,\n",
        "          size_layer=Info[\"bert_layers\"],\n",
        "          Test_resource=Test_resource,\n",
        "          treat_text_fun=treat_text_fun)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "w9V-_m7Ne49G",
      "metadata": {
        "id": "w9V-_m7Ne49G"
      },
      "source": [
        "## Model evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "XNlkp4iRdEeO",
      "metadata": {
        "id": "XNlkp4iRdEeO"
      },
      "outputs": [],
      "source": [
        "Valid_resource.groupby('domain')['label'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "zYEnZZLqHyb-",
      "metadata": {
        "id": "zYEnZZLqHyb-"
      },
      "source": [
        "### Task diagnosis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ikoenNhwJ85P",
      "metadata": {
        "id": "ikoenNhwJ85P"
      },
      "outputs": [],
      "source": [
        "from sklearn.manifold import TSNE\n",
        "import seaborn as sns\n",
        "\n",
        "# Initializing model\n",
        "model_to_finetunning = deepcopy(model)\n",
        "\n",
        "# Creating validation tasks\n",
        "valid = MetaTask(Valid_resource,\n",
        "                 num_task = 500,\n",
        "                 k_support=10,\n",
        "                 k_query=20,\n",
        "                 tokenizer = Info['tokenizer'],\n",
        "                 training=False)\n",
        "\n",
        "# Diagnostic dataset\n",
        "i = valid.task_names =='Opiods.csv'\n",
        "\n",
        "# Task index\n",
        "idx = np.array(range(len(i)))[i].item()\n",
        "\n",
        "# Support (train) e query (test) data\n",
        "support = valid[idx][0]\n",
        "query   = valid[idx][1]\n",
        "name   = valid[idx][2]\n",
        "\n",
        "print(name)\n",
        "print(Valid_resource[Valid_resource['domain']== name]['label'].value_counts())\n",
        "print(\"k_suport_examples:\",len(support))\n",
        "print(\"k_query_examples:\",len(query))\n",
        "\n",
        "# Support data loader\n",
        "support_dataloader = DataLoader(support, sampler=RandomSampler(support),\n",
        "                                batch_size=5)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "oiBSWSB2dUh4",
      "metadata": {
        "id": "oiBSWSB2dUh4"
      },
      "source": [
        "#### Untrained model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "jB22A0rOJ_uD",
      "metadata": {
        "id": "jB22A0rOJ_uD"
      },
      "outputs": [],
      "source": [
        "model_to_finetunning.to(device)\n",
        "\n",
        "# Inner Optimizer\n",
        "inner_optimizer = Adam(model_to_finetunning.parameters(), lr=5e-5)\n",
        "\n",
        "\n",
        "# Predicting\n",
        "model_to_finetunning.eval()\n",
        "with torch.no_grad():\n",
        "    query_dataloader = DataLoader(query, sampler=None, batch_size=len(query))\n",
        "    query_batch = iter(query_dataloader).next()\n",
        "    query_batch = tuple(t.to(device) for t in query_batch)\n",
        "    q_input_ids, q_attention_mask, q_token_type_ids, q_label_id = query_batch\n",
        "    \n",
        "    # Predictions\n",
        "    _, features, predictions = model_to_finetunning(q_input_ids, q_attention_mask, q_token_type_ids, labels = q_label_id)\n",
        "\n",
        "    predictions = predictions.detach().cpu().squeeze()\n",
        "    q_label_id = q_label_id.detach().cpu()\n",
        "\n",
        "    acc = fn.accuracy(predictions, q_label_id).item()\n",
        "    print(\"acc:\",acc)\n",
        "\n",
        "# TSNE Dimensionality reduction\n",
        "X_embedded = TSNE(n_components=2, learning_rate='auto',\n",
        "                  init='random').fit_transform(features[0].to('cpu'))\n",
        "\n",
        "# Plot\n",
        "sns.scatterplot(x=X_embedded[:, 0],\n",
        "                y=X_embedded[:, 1],\n",
        "                hue=q_label_id)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "QKoI4C-zeOLM",
      "metadata": {
        "id": "QKoI4C-zeOLM"
      },
      "source": [
        "#### Trained model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "UTw968K405Yn",
      "metadata": {
        "id": "UTw968K405Yn"
      },
      "outputs": [],
      "source": [
        "model_to_finetunning = deepcopy(model)\n",
        "inner_optimizer = Adam(model_to_finetunning.parameters(), lr=5e-5)\n",
        "model_to_finetunning.train()\n",
        "model_to_finetunning.to(device)\n",
        "\n",
        "# Inner loop training\n",
        "for i in range(0,Info['inner_update_step']):\n",
        "    all_loss = []\n",
        "\n",
        "    # Inner training batch (support set)\n",
        "    for inner_step, batch in enumerate(support_dataloader):\n",
        "        \n",
        "        batch = tuple(t.to(\"cuda\") for t in batch)\n",
        "        input_ids, attention_mask, token_type_ids, label_id = batch\n",
        "\n",
        "        # Feed Foward\n",
        "        loss, _, _ = model_to_finetunning(input_ids, attention_mask, token_type_ids=token_type_ids, labels = label_id)\n",
        "                      \n",
        "        loss.backward()\n",
        "        inner_optimizer.step()\n",
        "        inner_optimizer.zero_grad()\n",
        "        \n",
        "        all_loss.append(loss.item())\n",
        "    \n",
        "    if i % Info[\"inner_print\"] == 0:\n",
        "        print(\"Inner Loss: \", np.mean(all_loss))\n",
        "\n",
        "# Predicting\n",
        "model_to_finetunning.eval()\n",
        "with torch.no_grad():\n",
        "    query_dataloader = DataLoader(query, sampler=None, batch_size=len(query))\n",
        "    query_batch = iter(query_dataloader).next()\n",
        "    query_batch = tuple(t.to(device) for t in query_batch)\n",
        "    q_input_ids, q_attention_mask, q_token_type_ids, q_label_id = query_batch\n",
        "    \n",
        "    # Predictions\n",
        "    _, features, predictions = model_to_finetunning(q_input_ids, q_attention_mask, q_token_type_ids, labels = q_label_id)\n",
        "\n",
        "    predictions = predictions.detach().cpu().squeeze()\n",
        "    q_label_id = q_label_id.detach().cpu()\n",
        "\n",
        "    acc = fn.accuracy(predictions, q_label_id).item()\n",
        "    print(\"acc:\",acc)\n",
        "\n",
        "\n",
        "\n",
        "model_to_finetunning.to(torch.device('cpu'))\n",
        "del  inner_optimizer, model_to_finetunning\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "\n",
        "# TSNE Dimensionality reduction\n",
        "X_embedded = TSNE(n_components=2, learning_rate='auto',\n",
        "                  init='random').fit_transform(features[0].to('cpu'))\n",
        "\n",
        "# Plot\n",
        "sns.scatterplot(x=X_embedded[:, 0],\n",
        "                y=X_embedded[:, 1],\n",
        "                hue=q_label_id,\n",
        "                alpha=torch.sigmoid(features[1]).to('cpu').view(-1))\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "aXVhqbScO0GB",
      "metadata": {
        "id": "aXVhqbScO0GB"
      },
      "source": [
        "## Domain learning phase\n",
        " \n",
        "Evaluates the model in domain learner phase on the validation resource"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "tl5C-7f5-Zbm",
      "metadata": {
        "id": "tl5C-7f5-Zbm"
      },
      "outputs": [],
      "source": [
        "Valid_resource.groupby('domain')['label'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "CmXXb4wGglSs",
      "metadata": {
        "id": "CmXXb4wGglSs"
      },
      "source": [
        "### Tasks diagnosis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "j7MZtpEjIeeH",
      "metadata": {
        "id": "j7MZtpEjIeeH"
      },
      "outputs": [],
      "source": [
        "# model\n",
        "\n",
        "# Info = {\n",
        "#     \"inner_print\": 1, \n",
        "#     \"bert_layers\": 3,\n",
        "#     \"device\": torch.device('cuda' if torch.cuda.is_available() else 'cpu'),\n",
        "#     # \"model\": model,\n",
        "#     \"tokenizer\": initializer_bert.tokenizer,\n",
        "#     \"max_seq_length\": 512,\n",
        "#     \"meta_epoch\":30, # Numero de epocas do outerloop\n",
        "#     \"k_spt\":20, # Numero de treino por classe (k_spt) caso binario\n",
        "#     \"k_qry\":20, # Numero de valicao por classe (k_spt) caso binario\n",
        "#     \"outer_batch_size\": 5, # Divide as tasks em batchs tasks\n",
        "#     \"inner_batch_size\": 5, # Divide as classificacao em batch de classificao\n",
        "#     \"outer_update_lr\" : 5e-5, # Learning rate do otimizador das tasks\n",
        "#     \"inner_update_lr\" : 5e-5, # Learning rate do otimizador das classificao\n",
        "#     \"inner_update_step\" : 3, # Numero de epocas dentro do inner loop\n",
        "#     \"inner_update_step_eval\": 3, # Numero de epocas dentro do inner loop de validacao\n",
        "#     \"num_task_train\" : 100, # Quantidade de tarefas de treino\n",
        "#     \"num_task_test\" : 5 # Quantidade de tarefas de test\n",
        "# }\n",
        "\n",
        "Info['threshold'] = 0.9\n",
        "Info[\"inner_update_step_eval\"] = 3\n",
        "Info[\"inner_print\"] = 1"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8wJDcXqCkwFC",
      "metadata": {
        "id": "8wJDcXqCkwFC"
      },
      "source": [
        "It's possible to access some of the data from the testing dataset after pressing \"Train\" in the object stantiated by the `diagnosis`, such as:\n",
        "\n",
        "+ `logits`: logits from classifier stage, no activation\n",
        "\n",
        "+ `X_embedded`: 2-dimensional values from dimensionality reduction of the latent space\n",
        "\n",
        "+ `features`: Latent space values  (feature_map layer output)\n",
        "\n",
        "+ `labels`: True values\n",
        "\n",
        "+ `data_train`: Training data (Not the same order given to the model on training)\n",
        "\n",
        "+ `data_test`: Testing data\n",
        "\n",
        "+ `batch_size_test`: Batch size from the testing dataset, so that prediction time can be reduced\n",
        "\n",
        "*After press Train Button to perform a domain learning, it's possible evaluate the text used to predict a label by the model in the [Domain Text Avaliation of Positives examples](#another_cell)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "id": "HySCP9L69uZn",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000,
          "referenced_widgets": [
            "ad43ae3bc05748f2a98bfa4a0139a5d4",
            "44230fef369f464b8614dfaf34487ef4",
            "bf933563c73f4c0bb1c82ced2e9fe3a9",
            "1fd7d67a9c374528b61437c492723cd2",
            "9a18e6b60f5f470286481e3ae989666a",
            "76bf2306b7374f068c8217dec3bf7109",
            "6433e0e4b56e45a09583f45aaec6a225",
            "2ea725f9889b46ea99b86cdb7d22646d",
            "436e079ade744a93af52827b1b144a48",
            "8498dcfa282647d2bb8f1706141fcf6c",
            "d4ab0c65e770443e8681fdafbd195eb0",
            "42b02f7a46fb42179882f10905bf69f0",
            "7b6ac178ea7f49e9999d0d27ac745e64",
            "34e4c0033e194fc4a47a24830c2385bc",
            "f8420963cef1439f8330e4e5caa674fa",
            "b069c1118bdf4223a069da3e9d3453c4",
            "ddb88414f204442a9138c51b09d0f9b5",
            "4665ce144b144b159e6042d23a79adce",
            "bc404addb52b45fd88391fdb992477fe",
            "8daea4e296ea4dd7ad15a8c8627753ad",
            "af9a91aa77774620b545c3e1047e411d"
          ]
        },
        "id": "HySCP9L69uZn",
        "outputId": "8e40a20c-89fd-46f0-b212-7dca3bf10797"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Head_and_neck_cancer_bone.csv\n",
            "-------Train data-------\n",
            "negative    10\n",
            "positive    10\n",
            "Name: label, dtype: int64\n",
            "-------Test data-------\n",
            "negative    256\n",
            "positive     22\n",
            "Name: label, dtype: int64\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "ad43ae3bc05748f2a98bfa4a0139a5d4",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "Button(description='Next', style=ButtonStyle())"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "8daea4e296ea4dd7ad15a8c8627753ad",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(Button(description='Evaluation', style=ButtonStyle()), FloatText(value=0.95, description='tresh…"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "1fd7d67a9c374528b61437c492723cd2",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(Button(description='Train', style=ButtonStyle()), IntText(value=10, description='size')))"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WSS@95:0.3646, R: 0.9545\n",
            "ASSWSS@95:0.396\n",
            "Acc.: 0.482\n",
            "F1-score: 0.2258\n",
            "Treshold to wss95: 0.5134999752044678\n",
            "\n",
            "Confusion matrix:\n",
            "       Predict     \n",
            "             0    1\n",
            "Real 0     113  143\n",
            "     1       1   21\n",
            "\n",
            "---Metrics with threshold: 0.9 ----\n",
            "\n",
            "WSS@R:0.0, R: 0.0\n",
            "AWSS@R:0.0\n",
            "Acc.: 0.9209\n",
            "F1-score: 0.0\n",
            "\n",
            "Confusion matrix:\n",
            "       Predict   \n",
            "             0  1\n",
            "Real 0     256  0\n",
            "     1      22  0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/seaborn/relational.py:654: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
            "  kws[\"alpha\"] = 1 if self.alpha == \"auto\" else self.alpha\n",
            "/usr/local/lib/python3.7/dist-packages/seaborn/relational.py:654: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
            "  kws[\"alpha\"] = 1 if self.alpha == \"auto\" else self.alpha\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1800x720 with 4 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Evaluating validation dataset\n",
        "batch_size_test =   20 #@param {type:\"number\"}\n",
        "# Task names\n",
        "names = Valid_resource['domain'].unique()\n",
        "\n",
        "diagnosis5050 = diagnosis(names, Valid_resource, batch_size_test, model, Info, device,treat_text_fun=treat_text_fun, start=0)\n",
        "diagnosis5050()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2Uqfxt_6eq2h",
      "metadata": {
        "id": "2Uqfxt_6eq2h"
      },
      "source": [
        "### Domain Text Avaliation of Positives examples <a id='Text_avaliation'></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Mj0DnVZivqp7",
      "metadata": {
        "id": "Mj0DnVZivqp7"
      },
      "outputs": [],
      "source": [
        "data_test = diagnosis5050.data_test\n",
        "logits = diagnosis5050.logits\n",
        "\n",
        "# random choice a positive example\n",
        "indx= data_test[data_test['label'] == 'positive'].index\n",
        "indx= np.random.choice(indx)\n",
        "\n",
        "\n",
        "# print the example\n",
        "pprint(data_test.iloc[indx])\n",
        "\n",
        "# Prediction by the model\n",
        "print(\"Predicted:\",torch.sigmoid(logits[indx]).item() )\n",
        "\n",
        "# Text of the example\n",
        "print('Treated Text:')\n",
        "pprint(treat_text_fun(data_test['text'].iloc[indx]))\n",
        "\n",
        "# Text of the example\n",
        "print('Text:')\n",
        "pprint(treat_text_fun(data_test['text'].iloc[indx]))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "gsJ2j0f4MH5P",
      "metadata": {
        "id": "gsJ2j0f4MH5P"
      },
      "source": [
        "## Save model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "eUBZ0xQvMHR5",
      "metadata": {
        "id": "eUBZ0xQvMHR5"
      },
      "outputs": [],
      "source": [
        "import shutil\n",
        "import datetime\n",
        "import re\n",
        "import json\n",
        "from pathlib import Path\n",
        "\n",
        "base_path = '5050split'\n",
        "path_save = \"./\"+\"Models/\"+base_path+\"/\"\n",
        "\n",
        "\n",
        "# Creating directory\n",
        "Path(path_save).mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "# Directory data\n",
        "check = (str(datetime.datetime.now()))[0:19]\n",
        "check = re.sub(\"[:-]\",\"_\",check)\n",
        "check = re.sub(\" \",\"_hr_\",check)\n",
        "\n",
        "print(\"Data e hora do salvamento:\", check)\n",
        "\n",
        "# Creating directory\n",
        "Path(f\"{path_save}/{check}\").mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "# Saving paths\n",
        "model_path = f'{path_save}/{check}/model.pt'\n",
        "meta_info_path = f'{path_save}/{check}/Info.json'\n",
        "\n",
        "# Meta info\n",
        "save_info = Info.copy()\n",
        "save_info['model'] = initializer_model.tokenizer.name_or_path\n",
        "save_info.pop(\"tokenizer\")\n",
        "\n",
        "## Saving meta info\n",
        "with open(meta_info_path, 'w') as fp:\n",
        "    json.dump(save_info, fp)\n",
        "\n",
        "## Saving entire model\n",
        "torch.save(model, model_path)\n",
        "\n",
        "# To save only parameters:\n",
        "# torch.save(model.state_dict(), model_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Qz8B6OOIbkW1",
      "metadata": {
        "id": "Qz8B6OOIbkW1"
      },
      "source": [
        "## Load model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "HYn3Rwvvr0Sj",
      "metadata": {
        "id": "HYn3Rwvvr0Sj"
      },
      "outputs": [],
      "source": [
        "# Downloading entire model\n",
        "model = torch.load(model_path)\n",
        "model"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "mShjJAP5qFuh",
      "metadata": {
        "id": "mShjJAP5qFuh"
      },
      "source": [
        "## Computing simulation attemps\n",
        "\n",
        "5 attemps in the domain learner phase with the validation resource is computed to evaluate the performance of the model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "rjWkAFtbrWk5",
      "metadata": {
        "id": "rjWkAFtbrWk5"
      },
      "outputs": [],
      "source": [
        "names_to_valid = Valid_resource['domain'].unique()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "LyEra68ZrBFR",
      "metadata": {
        "id": "LyEra68ZrBFR"
      },
      "outputs": [],
      "source": [
        "torch.clear_autocast_cache()\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "base_path = '5050split'\n",
        "path_save = \"./\"+\"Results/\"+base_path+\"/\"\n",
        "\n",
        "pipeline_simulation(Valid_resource=Valid_resource,\n",
        "                    names_to_valid=names_to_valid,\n",
        "                    path_save = path_save,\n",
        "                    model= model,\n",
        "                    Info=Info,\n",
        "                    device=device,\n",
        "                    initializer_model=initializer_model,\n",
        "                    treat_text_fun=treat_text_fun)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "UHyBqbJNwzXA",
      "metadata": {
        "id": "UHyBqbJNwzXA"
      },
      "source": [
        "# Comparison simulation\n",
        "\n",
        "This section explore the methodology of train the ML-SLRC with the remain dataset that don't correspond the Benchmarks datasets, [SWIFT](https://pubmed.ncbi.nlm.nih.gov/27216467/) and [cohen Drugs Review](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC1447545/) to peform a comparison of WSS@95 in the ([Kusa at al., 2022](https://arxiv.org/abs/2201.07534)).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d_Jp8EaAwzXB",
      "metadata": {
        "id": "d_Jp8EaAwzXB"
      },
      "source": [
        "### Directory creation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4vSHwaa7xZ1P",
      "metadata": {
        "id": "4vSHwaa7xZ1P"
      },
      "outputs": [],
      "source": [
        "import glob\n",
        "import os\n",
        "\n",
        "path = 'SLR_data'\n",
        "\n",
        "cohen_paths = glob.glob(f\"{path}/**/cohen/*.csv\", recursive=True)\n",
        "SWIFT_paths = glob.glob(f\"{path}/**/SWIFT systematic review data/*.csv\", recursive=True)\n",
        "\n",
        "cohen_names = [os.path.basename(p) for p in cohen_paths]\n",
        "SWIFT_names = [os.path.basename(p) for p in SWIFT_paths]\n",
        "\n",
        "base_path = 'Comparison'"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fv1TvfW-wzXC",
      "metadata": {
        "id": "fv1TvfW-wzXC"
      },
      "source": [
        "#### Data split"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Nc_73DYFyyDn",
      "metadata": {
        "id": "Nc_73DYFyyDn"
      },
      "outputs": [],
      "source": [
        "from itertools import chain\n",
        "\n",
        "All_data = load_data(\n",
        "    info_load\n",
        ")\n",
        "\n",
        "All_data = All_data.dropna().reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "comparison_names = list(chain.from_iterable([cohen_names, SWIFT_names]))\n",
        "\n",
        "cohen_data = All_data[All_data['domain'].isin(cohen_names)]\n",
        "cohen_data =  cohen_data.reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "SWIFT_data = All_data[All_data['domain'].isin(SWIFT_names)]\n",
        "SWIFT_data =  SWIFT_data.reset_index().drop(\"index\", axis=1)\n",
        "\n",
        "Train_resource = All_data[~All_data['domain'].isin(comparison_names)]\n",
        "Train_resource =  Train_resource.reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "LdGqKwZ4wzXC",
      "metadata": {
        "id": "LdGqKwZ4wzXC"
      },
      "outputs": [],
      "source": [
        "# Selecting data with at least 40 words separated by spaces\n",
        "crit = Train_resource[\"text\"].apply(lambda x: len(x.split(\" \"))) >= 40\n",
        "Train_resource = Train_resource[crit].reset_index().drop(\"index\", axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "IM4SBF4CwzXD",
      "metadata": {
        "id": "IM4SBF4CwzXD"
      },
      "source": [
        "### Exploratory Data Analysis\n",
        "\n",
        "Histograms of number of words separated by \" \" and count of positive and negative examples of each dataset of the resource"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "zE5FeDmUwzXD",
      "metadata": {
        "id": "zE5FeDmUwzXD"
      },
      "source": [
        "#### Train Resource\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6RduBiDVwzXE",
      "metadata": {
        "id": "6RduBiDVwzXE"
      },
      "outputs": [],
      "source": [
        "Train_resource[\"text\"].apply(lambda x: len(x.split(\" \"))).hist()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "PT03s--fwzXE",
      "metadata": {
        "id": "PT03s--fwzXE"
      },
      "outputs": [],
      "source": [
        "Train_resource.groupby('domain')['label']\\\n",
        "              .value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "GplApKOfwzXE",
      "metadata": {
        "id": "GplApKOfwzXE"
      },
      "source": [
        "#### cohen Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5p1tAYcSwzXE",
      "metadata": {
        "id": "5p1tAYcSwzXE"
      },
      "outputs": [],
      "source": [
        "cohen_data[\"text\"].apply(lambda x: len(x.split(\" \"))).hist()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "qPCW62_XwzXE",
      "metadata": {
        "id": "qPCW62_XwzXE"
      },
      "outputs": [],
      "source": [
        "cohen_data.groupby('domain')['label']\\\n",
        "              .value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "YXLQORwJwzXE",
      "metadata": {
        "id": "YXLQORwJwzXE"
      },
      "source": [
        "#### SWIFT Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "yegMKoehwzXE",
      "metadata": {
        "id": "yegMKoehwzXE"
      },
      "outputs": [],
      "source": [
        "SWIFT_data[\"text\"].apply(lambda x: len(x.split(\" \"))).hist()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "T6qSFORtwzXE",
      "metadata": {
        "id": "T6qSFORtwzXE"
      },
      "outputs": [],
      "source": [
        "SWIFT_data.groupby('domain')['label']\\\n",
        "              .value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "YFxdu9b2wzXE",
      "metadata": {
        "id": "YFxdu9b2wzXE"
      },
      "source": [
        "## Meta learning phase"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4RZcNhCawzXE",
      "metadata": {
        "id": "4RZcNhCawzXE"
      },
      "outputs": [],
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Meta-Training informations\n",
        "Info = {\n",
        "    \"inner_print\": 2, \n",
        "    \"bert_layers\": 2,\n",
        "    \"tokenizer\": initializer_model.tokenizer,\n",
        "    \"max_seq_length\": 512,\n",
        "    \"meta_epoch\":5, # Outer loop epochs\n",
        "    \"k_spt\":8, # Support (training) examples per class, binary case\n",
        "    \"k_qry\":8, # Query (testing) examples per class, binary case\n",
        "    \"outer_batch_size\": 5, # Size of batch of tasks\n",
        "    \"inner_batch_size\": 4, # Size of batch of classifications\n",
        "    \"outer_update_lr\" : 5e-5, # Learning rate of task optimizer\n",
        "    \"inner_update_lr\" : 5e-5, # Learning rate of classification optimizer\n",
        "    \"inner_update_step\" : 4, # Inner loop epochs\n",
        "    \"inner_update_step_eval\": 4, # Validation inner loop epochs\n",
        "    \"num_task_train\" : 2, # Number of training tasks\n",
        "    # \"num_task_test\" : 5 # Number of testing tasks\n",
        "    \"pos_weight\" : 3 # p > 1 increases recall, p < 1 increases precision, applied in loss function\n",
        "}\n",
        "\n",
        "model = SLR_Classifier(bert_layers = range(Info[\"bert_layers\"]),\n",
        "                       model = initializer_model.model.bert,\n",
        "                       drop=0.2)\n",
        "\n",
        "\n",
        "meta_train(data = Train_resource,\n",
        "          model = model,\n",
        "          device = device,\n",
        "          Info = Info,\n",
        "          print_epoch =True,\n",
        "          size_layer=Info[\"bert_layers\"],\n",
        "          Test_resource=None,\n",
        "          treat_text_fun= treat_text_fun)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6PoUx5zCwzXE",
      "metadata": {
        "id": "6PoUx5zCwzXE"
      },
      "source": [
        "## Model evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "YC0BpcIbwzXF",
      "metadata": {
        "id": "YC0BpcIbwzXF"
      },
      "outputs": [],
      "source": [
        "SWIFT_data.groupby('domain')['label'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ubocseqWwzXF",
      "metadata": {
        "id": "ubocseqWwzXF"
      },
      "source": [
        "### Task diagnosis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "pP96xFMYwzXF",
      "metadata": {
        "id": "pP96xFMYwzXF"
      },
      "outputs": [],
      "source": [
        "from sklearn.manifold import TSNE\n",
        "import seaborn as sns\n",
        "\n",
        "# Initializing model\n",
        "model_to_finetunning = deepcopy(model)\n",
        "\n",
        "# Creating validation tasks\n",
        "valid = MetaTask(SWIFT_data,\n",
        "                 num_task = 500,\n",
        "                 k_support=10,\n",
        "                 k_query=20,\n",
        "                 tokenizer = Info['tokenizer'],\n",
        "                 training=False)\n",
        "\n",
        "# Diagnostic dataset\n",
        "i = valid.task_names =='Neuropain.csv'\n",
        "\n",
        "# Task index\n",
        "idx = np.array(range(len(i)))[i].item()\n",
        "\n",
        "# Support (train) e query (test) data\n",
        "support = valid[idx][0]\n",
        "query   = valid[idx][1]\n",
        "name   = valid[idx][2]\n",
        "\n",
        "print(name)\n",
        "print(SWIFT_data[SWIFT_data['domain']== name]['label'].value_counts())\n",
        "print(\"k_suport_examples:\",len(support))\n",
        "print(\"k_query_examples:\",len(query))\n",
        "\n",
        "# Support data loader\n",
        "support_dataloader = DataLoader(support, sampler=RandomSampler(support),\n",
        "                                batch_size=5)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "I9txQb_FwzXF",
      "metadata": {
        "id": "I9txQb_FwzXF"
      },
      "source": [
        "#### Untrained model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Hh6PlZ7NwzXF",
      "metadata": {
        "id": "Hh6PlZ7NwzXF"
      },
      "outputs": [],
      "source": [
        "model_to_finetunning.to(device)\n",
        "\n",
        "# Inner Optimizer\n",
        "inner_optimizer = Adam(model_to_finetunning.parameters(), lr=5e-5)\n",
        "\n",
        "\n",
        "# Predicting\n",
        "model_to_finetunning.eval()\n",
        "with torch.no_grad():\n",
        "    query_dataloader = DataLoader(query, sampler=None, batch_size=len(query))\n",
        "    query_batch = iter(query_dataloader).next()\n",
        "    query_batch = tuple(t.to(device) for t in query_batch)\n",
        "    q_input_ids, q_attention_mask, q_token_type_ids, q_label_id = query_batch\n",
        "    \n",
        "    # Predictions\n",
        "    _, features, predictions = model_to_finetunning(q_input_ids, q_attention_mask, q_token_type_ids, labels = q_label_id)\n",
        "\n",
        "    predictions = predictions.detach().cpu().squeeze()\n",
        "    q_label_id = q_label_id.detach().cpu()\n",
        "\n",
        "    acc = fn.accuracy(predictions, q_label_id).item()\n",
        "    print(\"acc:\",acc)\n",
        "\n",
        "# TSNE Dimensionality reduction\n",
        "X_embedded = TSNE(n_components=2, learning_rate='auto',\n",
        "                  init='random').fit_transform(features[0].to('cpu'))\n",
        "\n",
        "# Plot\n",
        "sns.scatterplot(x=X_embedded[:, 0],\n",
        "                y=X_embedded[:, 1],\n",
        "                hue=q_label_id)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7WbLwkFGwzXF",
      "metadata": {
        "id": "7WbLwkFGwzXF"
      },
      "source": [
        "#### Trained model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ZhaBzCtZwzXF",
      "metadata": {
        "id": "ZhaBzCtZwzXF"
      },
      "outputs": [],
      "source": [
        "model_to_finetunning = deepcopy(model)\n",
        "inner_optimizer = Adam(model_to_finetunning.parameters(), lr=5e-5)\n",
        "model_to_finetunning.train()\n",
        "model_to_finetunning.to(device)\n",
        "\n",
        "# Inner loop training\n",
        "for i in range(0,Info['inner_update_step']):\n",
        "    all_loss = []\n",
        "\n",
        "    # Inner training batch (support set)\n",
        "    for inner_step, batch in enumerate(support_dataloader):\n",
        "        \n",
        "        batch = tuple(t.to(\"cuda\") for t in batch)\n",
        "        input_ids, attention_mask, token_type_ids, label_id = batch\n",
        "\n",
        "        # Feed Foward\n",
        "        loss, _, _ = model_to_finetunning(input_ids, attention_mask, token_type_ids=token_type_ids, labels = label_id)\n",
        "                      \n",
        "        loss.backward()\n",
        "        inner_optimizer.step()\n",
        "        inner_optimizer.zero_grad()\n",
        "        \n",
        "        all_loss.append(loss.item())\n",
        "    \n",
        "    if i % Info[\"inner_print\"] == 0:\n",
        "        print(\"Inner Loss: \", np.mean(all_loss))\n",
        "\n",
        "# Predicting\n",
        "model_to_finetunning.eval()\n",
        "with torch.no_grad():\n",
        "    query_dataloader = DataLoader(query, sampler=None, batch_size=len(query))\n",
        "    query_batch = iter(query_dataloader).next()\n",
        "    query_batch = tuple(t.to(device) for t in query_batch)\n",
        "    q_input_ids, q_attention_mask, q_token_type_ids, q_label_id = query_batch\n",
        "    \n",
        "    # Predictions\n",
        "    _, features, predictions = model_to_finetunning(q_input_ids, q_attention_mask, q_token_type_ids, labels = q_label_id)\n",
        "\n",
        "    predictions = predictions.detach().cpu().squeeze()\n",
        "    q_label_id = q_label_id.detach().cpu()\n",
        "\n",
        "    acc = fn.accuracy(predictions, q_label_id).item()\n",
        "    print(\"acc:\",acc)\n",
        "\n",
        "\n",
        "\n",
        "model_to_finetunning.to(torch.device('cpu'))\n",
        "del  inner_optimizer, model_to_finetunning\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "\n",
        "# TSNE Dimensionality reduction\n",
        "X_embedded = TSNE(n_components=2, learning_rate='auto',\n",
        "                  init='random').fit_transform(features[0].to('cpu'))\n",
        "\n",
        "# Plot\n",
        "sns.scatterplot(x=X_embedded[:, 0],\n",
        "                y=X_embedded[:, 1],\n",
        "                hue=q_label_id,\n",
        "                alpha=torch.sigmoid(features[1]).to('cpu').view(-1))\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "LabRu1wowzXF",
      "metadata": {
        "id": "LabRu1wowzXF"
      },
      "source": [
        "## Domain learning phase on SWIFT datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "IOSaoHXzwzXF",
      "metadata": {
        "id": "IOSaoHXzwzXF"
      },
      "outputs": [],
      "source": [
        "SWIFT_data.groupby('domain')['label'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "g7IemRYLwzXF",
      "metadata": {
        "id": "g7IemRYLwzXF"
      },
      "source": [
        "### Diagnosis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "lhzinGLHwzXF",
      "metadata": {
        "id": "lhzinGLHwzXF"
      },
      "outputs": [],
      "source": [
        "# model\n",
        "\n",
        "# Info = {\n",
        "#     \"inner_print\": 1, \n",
        "#     \"bert_layers\": 3,\n",
        "#     \"device\": torch.device('cuda' if torch.cuda.is_available() else 'cpu'),\n",
        "#     # \"model\": model,\n",
        "#     \"tokenizer\": initializer_bert.tokenizer,\n",
        "#     \"max_seq_length\": 512,\n",
        "#     \"meta_epoch\":30, # Numero de epocas do outerloop\n",
        "#     \"k_spt\":20, # Numero de treino por classe (k_spt) caso binario\n",
        "#     \"k_qry\":20, # Numero de valicao por classe (k_spt) caso binario\n",
        "#     \"outer_batch_size\": 5, # Divide as tasks em batchs tasks\n",
        "#     \"inner_batch_size\": 5, # Divide as classificacao em batch de classificao\n",
        "#     \"outer_update_lr\" : 5e-5, # Learning rate do otimizador das tasks\n",
        "#     \"inner_update_lr\" : 5e-5, # Learning rate do otimizador das classificao\n",
        "#     \"inner_update_step\" : 3, # Numero de epocas dentro do inner loop\n",
        "#     \"inner_update_step_eval\": 3, # Numero de epocas dentro do inner loop de validacao\n",
        "#     \"num_task_train\" : 100, # Quantidade de tarefas de treino\n",
        "#     \"num_task_test\" : 5 # Quantidade de tarefas de test\n",
        "# }\n",
        "\n",
        "Info['threshold'] = 0.9\n",
        "Info[\"inner_update_step_eval\"] = 3\n",
        "Info[\"inner_print\"] = 1"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "zHxarGVmwzXF",
      "metadata": {
        "id": "zHxarGVmwzXF"
      },
      "source": [
        "It's possible to access some of the data from the testing dataset after pressing \"Train\" in the object stantiated by the `diagnosis`, such as:\n",
        "\n",
        "+ `logits`: logits from classifier stage, no activation\n",
        "\n",
        "+ `X_embedded`: 2-dimensional values from dimensionality reduction of the latent space\n",
        "\n",
        "+ `features`: Latent space values  (feature_map layer output)\n",
        "\n",
        "+ `labels`: True values\n",
        "\n",
        "+ `data_train`: Training data (Not the same order given to the model on training)\n",
        "\n",
        "+ `data_test`: Testing data\n",
        "\n",
        "+ `batch_size_test`: Batch size from the testing dataset, so that prediction time can be reduced\n",
        "\n",
        "*After press Train Button to perform a domain learning, it's possible evaluate the text used to predict a label by the model in the [Domain Text Avaliation of Positives examples](#Text_avaliation_2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ztzWSxBFwzXG",
      "metadata": {
        "id": "ztzWSxBFwzXG"
      },
      "outputs": [],
      "source": [
        "#@title Evaluating validation dataset\n",
        "batch_size_test =   20 #@param {type:\"number\"}\n",
        "# Task names\n",
        "names = SWIFT_data['domain'].unique()\n",
        "\n",
        "diagnosis_comp = diagnosis(names, SWIFT_data, batch_size_test, model,Info,device,treat_text_fun=treat_text_fun, start=0)\n",
        "diagnosis_comp()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ENEiWehUwzXG",
      "metadata": {
        "id": "ENEiWehUwzXG"
      },
      "source": [
        "### Text Avaliation of Positives examples <a id='Text_avaliation_2'></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "XV7WbOpvwzXG",
      "metadata": {
        "id": "XV7WbOpvwzXG"
      },
      "outputs": [],
      "source": [
        "data_test = diagnosis_comp.data_test\n",
        "logits = diagnosis_comp.logits\n",
        "\n",
        "# random choice a positive example\n",
        "indx= data_test[data_test['label'] == 'positive'].index\n",
        "indx= np.random.choice(indx)\n",
        "\n",
        "\n",
        "# print the example\n",
        "pprint(data_test.iloc[indx])\n",
        "\n",
        "# Prediction by the model\n",
        "print(\"Predicted:\",torch.sigmoid(logits[indx]).item() )\n",
        "\n",
        "# Text of the example\n",
        "print('Treated Text:')\n",
        "pprint(treat_text_fun(data_test['text'].iloc[indx]))\n",
        "\n",
        "# Text of the example\n",
        "print('Text:')\n",
        "pprint(treat_text_fun(data_test['text'].iloc[indx]))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dBIbP0JkwzXG",
      "metadata": {
        "id": "dBIbP0JkwzXG"
      },
      "source": [
        "## Save model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "_eyoHAzqwzXG",
      "metadata": {
        "id": "_eyoHAzqwzXG"
      },
      "outputs": [],
      "source": [
        "import shutil\n",
        "import datetime\n",
        "import re\n",
        "import json\n",
        "from pathlib import Path\n",
        "\n",
        "base_path = 'Comparison'\n",
        "path_save = \"./\"+\"Models/\"+base_path+\"/\"\n",
        "\n",
        "\n",
        "\n",
        "# Creating directory\n",
        "Path(path_save).mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "# Directory data\n",
        "check = (str(datetime.datetime.now()))[0:19]\n",
        "check = re.sub(\"[:-]\",\"_\",check)\n",
        "check = re.sub(\" \",\"_hr_\",check)\n",
        "\n",
        "print(\"Data e hora do salvamento:\", check)\n",
        "\n",
        "# Creating directory\n",
        "Path(f\"{path_save}/{check}\").mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "# Saving paths\n",
        "model_path = f'{path_save}/{check}/model.pt'\n",
        "meta_info_path = f'{path_save}/{check}/Info.json'\n",
        "\n",
        "# Meta info\n",
        "save_info = Info.copy()\n",
        "save_info['model'] = initializer_model.tokenizer.name_or_path\n",
        "save_info.pop(\"tokenizer\")\n",
        "\n",
        "## Saving meta info\n",
        "with open(meta_info_path, 'w') as fp:\n",
        "    json.dump(save_info, fp)\n",
        "\n",
        "## Saving entire model\n",
        "torch.save(model, model_path)\n",
        "\n",
        "# To save only parameters:\n",
        "# torch.save(model.state_dict(), model_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "mNRCgVUZwzXG",
      "metadata": {
        "id": "mNRCgVUZwzXG"
      },
      "source": [
        "## Load model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "mC4eab1ywzXG",
      "metadata": {
        "id": "mC4eab1ywzXG"
      },
      "outputs": [],
      "source": [
        "# Downloading entire model\n",
        "model = torch.load(model_path)\n",
        "model"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8wpA9YtGwzXG",
      "metadata": {
        "id": "8wpA9YtGwzXG"
      },
      "source": [
        "## Computing simulation attemps on SWIFT datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "aagMZGmOwzXG",
      "metadata": {
        "id": "aagMZGmOwzXG"
      },
      "outputs": [],
      "source": [
        "torch.clear_autocast_cache()\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "path_save = \"./\"+\"Results/\"+base_path+\"/SWIFT/\"\n",
        "\n",
        "\n",
        "pipeline_simulation(Valid_resource=SWIFT_data,\n",
        "                    names_to_valid=SWIFT_names,\n",
        "                    path_save = path_save,\n",
        "                    model= model,\n",
        "                    Info=Info,\n",
        "                    device=device,\n",
        "                    initializer_model=initializer_model,\n",
        "                    treat_text_fun=treat_text_fun)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c00JK-eI_lOS",
      "metadata": {
        "id": "c00JK-eI_lOS"
      },
      "source": [
        "## Computing simulation attemps on cohen datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9oppuIkh_lOd",
      "metadata": {
        "id": "9oppuIkh_lOd"
      },
      "outputs": [],
      "source": [
        "torch.clear_autocast_cache()\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "path_save = \"./\"+\"Results/\"+base_path+\"/Drugs/\"\n",
        "\n",
        "pipeline_simulation(Valid_resource=cohen_data,\n",
        "                    names_to_valid=cohen_names,\n",
        "                    path_save = path_save,\n",
        "                    model= model,\n",
        "                    Info=Info,\n",
        "                    device=device,\n",
        "                    initializer_model=initializer_model,\n",
        "                    treat_text_fun=treat_text_fun)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "9kxoLXspGo2C",
        "uZMuTuO6t1qq",
        "yV9633efG0Ql",
        "op1ERM4lqODR",
        "dd636d02-621e-4c60-845a-ddc41aef74b5",
        "jJwL3bIiIpIp",
        "9SYTNYLQqWPG",
        "4S0AvO8AqjV3"
      ],
      "include_colab_link": true,
      "name": "Meta_learning_EFL.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Deep-Learning",
      "language": "python",
      "name": "deep-learning"
    },
    "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.8.12"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "041423664fae4effab4e45f7b36e821b": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "10c413604972498c9c18b6edd7a3ff04": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_4a9e3076d412448a93f78afa49c327c4",
              "IPY_MODEL_cc0ba4567b51479b8018c50a84c75c91"
            ],
            "layout": "IPY_MODEL_a1ba9712b5c940edad22cb5793eb32e5"
          }
        },
        "1fd7d67a9c374528b61437c492723cd2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_9a18e6b60f5f470286481e3ae989666a",
              "IPY_MODEL_76bf2306b7374f068c8217dec3bf7109"
            ],
            "layout": "IPY_MODEL_6433e0e4b56e45a09583f45aaec6a225"
          }
        },
        "2ea725f9889b46ea99b86cdb7d22646d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "34e4c0033e194fc4a47a24830c2385bc": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatTextModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatTextModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "FloatTextView",
            "continuous_update": false,
            "description": "tresh",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_4665ce144b144b159e6042d23a79adce",
            "step": null,
            "style": "IPY_MODEL_bc404addb52b45fd88391fdb992477fe",
            "value": 0.95
          }
        },
        "4043334cb0b1460185130dcaa68e490a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "42b02f7a46fb42179882f10905bf69f0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7b6ac178ea7f49e9999d0d27ac745e64",
              "IPY_MODEL_34e4c0033e194fc4a47a24830c2385bc"
            ],
            "layout": "IPY_MODEL_f8420963cef1439f8330e4e5caa674fa"
          }
        },
        "436e079ade744a93af52827b1b144a48": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "44230fef369f464b8614dfaf34487ef4": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4665ce144b144b159e6042d23a79adce": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4a9e3076d412448a93f78afa49c327c4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Previous",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_6381629d0ea94508a1e75d0a1307616e",
            "style": "IPY_MODEL_898677ad283547669a1a49c42a7c6dde",
            "tooltip": ""
          }
        },
        "53f6da0f43364fd9a268584d2c519ec7": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Next",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_dec715330b2d42e49d4bdba7f950dd80",
            "style": "IPY_MODEL_e91597dc946a4fe49641997c8b235a99",
            "tooltip": ""
          }
        },
        "6381629d0ea94508a1e75d0a1307616e": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "6433e0e4b56e45a09583f45aaec6a225": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "76bf2306b7374f068c8217dec3bf7109": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "IntTextModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "IntTextModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "IntTextView",
            "continuous_update": false,
            "description": "size",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_8498dcfa282647d2bb8f1706141fcf6c",
            "step": 1,
            "style": "IPY_MODEL_d4ab0c65e770443e8681fdafbd195eb0",
            "value": 10
          }
        },
        "7b6ac178ea7f49e9999d0d27ac745e64": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Evaluation",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_b069c1118bdf4223a069da3e9d3453c4",
            "style": "IPY_MODEL_ddb88414f204442a9138c51b09d0f9b5",
            "tooltip": ""
          }
        },
        "8498dcfa282647d2bb8f1706141fcf6c": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "898677ad283547669a1a49c42a7c6dde": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "8daea4e296ea4dd7ad15a8c8627753ad": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7b6ac178ea7f49e9999d0d27ac745e64",
              "IPY_MODEL_34e4c0033e194fc4a47a24830c2385bc"
            ],
            "layout": "IPY_MODEL_af9a91aa77774620b545c3e1047e411d"
          }
        },
        "9a18e6b60f5f470286481e3ae989666a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Train",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_2ea725f9889b46ea99b86cdb7d22646d",
            "style": "IPY_MODEL_436e079ade744a93af52827b1b144a48",
            "tooltip": ""
          }
        },
        "9dd08a63b9cc423989b25be15460f129": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Previous",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_e94b4e96e37a4761a360f9b83cf7c7db",
            "style": "IPY_MODEL_d1bca0c60e9a4c85ace130b9d00c5d0d",
            "tooltip": ""
          }
        },
        "a1ba9712b5c940edad22cb5793eb32e5": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ad43ae3bc05748f2a98bfa4a0139a5d4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Next",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_44230fef369f464b8614dfaf34487ef4",
            "style": "IPY_MODEL_bf933563c73f4c0bb1c82ced2e9fe3a9",
            "tooltip": ""
          }
        },
        "aefafdb701fc4395ab7f321eff068d8d": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_9dd08a63b9cc423989b25be15460f129",
              "IPY_MODEL_53f6da0f43364fd9a268584d2c519ec7"
            ],
            "layout": "IPY_MODEL_dc1390bdc7eb42279aed3030a5bc77e4"
          }
        },
        "af9a91aa77774620b545c3e1047e411d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b069c1118bdf4223a069da3e9d3453c4": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "bc404addb52b45fd88391fdb992477fe": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "bf933563c73f4c0bb1c82ced2e9fe3a9": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "cc0ba4567b51479b8018c50a84c75c91": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Next",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_041423664fae4effab4e45f7b36e821b",
            "style": "IPY_MODEL_4043334cb0b1460185130dcaa68e490a",
            "tooltip": ""
          }
        },
        "d1bca0c60e9a4c85ace130b9d00c5d0d": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "d4ab0c65e770443e8681fdafbd195eb0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "dc1390bdc7eb42279aed3030a5bc77e4": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ddb88414f204442a9138c51b09d0f9b5": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "dec715330b2d42e49d4bdba7f950dd80": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e91597dc946a4fe49641997c8b235a99": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "e94b4e96e37a4761a360f9b83cf7c7db": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "f8420963cef1439f8330e4e5caa674fa": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}