demo_multilabel_classification_CSA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "demo_multilabel_classification_CSA.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO7lpQ2h+0j2ULlqSiMZQZq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/drive/1z9_ijDdqHNqNah6olqpMUkh8F15kpu5G#scrollTo=j-JijnqQbdmC\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install --upgrade --force-reinstall git+https://ntienvu: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@github.com/ntienvu/confident_sinkhorn_allocation"
      ],
      "metadata": {
        "id": "53ok293zvVnp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "8856d93e-69c5-4d68-f114-01a43d4ea94c"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting git+https://ntienvu:****@github.com/ntienvu/confident_sinkhorn_allocation\n",
            "  Cloning https://ntienvu:****@github.com/ntienvu/confident_sinkhorn_allocation to /tmp/pip-req-build-62bjunty\n",
            "  Running command git clone -q 'https://ntienvu:****@github.com/ntienvu/confident_sinkhorn_allocation' /tmp/pip-req-build-62bjunty\n",
            "Collecting colorama>=0.4.5\n",
            "  Downloading colorama-0.4.5-py2.py3-none-any.whl (16 kB)\n",
            "Collecting cycler>=0.11.0\n",
            "  Downloading cycler-0.11.0-py3-none-any.whl (6.4 kB)\n",
            "Collecting fonttools>=4.33.3\n",
            "  Downloading fonttools-4.34.4-py3-none-any.whl (944 kB)\n",
            "\u001b[K     |████████████████████████████████| 944 kB 5.0 MB/s \n",
            "\u001b[?25hCollecting joblib>=1.1.0\n",
            "  Downloading joblib-1.1.0-py2.py3-none-any.whl (306 kB)\n",
            "\u001b[K     |████████████████████████████████| 306 kB 42.7 MB/s \n",
            "\u001b[?25hCollecting kiwisolver>=1.4.3\n",
            "  Downloading kiwisolver-1.4.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (1.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.1 MB 36.2 MB/s \n",
            "\u001b[?25hCollecting matplotlib>=3.1.2\n",
            "  Downloading matplotlib-3.5.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (11.2 MB)\n",
            "\u001b[K     |████████████████████████████████| 11.2 MB 40.2 MB/s \n",
            "\u001b[?25hCollecting numpy>=1.21.0\n",
            "  Downloading numpy-1.21.6-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (15.7 MB)\n",
            "\u001b[K     |████████████████████████████████| 15.7 MB 48.9 MB/s \n",
            "\u001b[?25hCollecting packaging>=21.3\n",
            "  Downloading packaging-21.3-py3-none-any.whl (40 kB)\n",
            "\u001b[K     |████████████████████████████████| 40 kB 6.4 MB/s \n",
            "\u001b[?25hCollecting pandas>=1.2.3\n",
            "  Downloading pandas-1.3.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (11.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 11.3 MB 42.1 MB/s \n",
            "\u001b[?25hCollecting Pillow>=9.2.0\n",
            "  Downloading Pillow-9.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 3.1 MB 43.9 MB/s \n",
            "\u001b[?25hCollecting pyparsing>=3.0.9\n",
            "  Downloading pyparsing-3.0.9-py3-none-any.whl (98 kB)\n",
            "\u001b[K     |████████████████████████████████| 98 kB 8.8 MB/s \n",
            "\u001b[?25hCollecting python-dateutil>=2.8.2\n",
            "  Downloading python_dateutil-2.8.2-py2.py3-none-any.whl (247 kB)\n",
            "\u001b[K     |████████████████████████████████| 247 kB 60.4 MB/s \n",
            "\u001b[?25hCollecting pytz>=2022.1\n",
            "  Downloading pytz-2022.1-py2.py3-none-any.whl (503 kB)\n",
            "\u001b[K     |████████████████████████████████| 503 kB 47.7 MB/s \n",
            "\u001b[?25hCollecting scikit-learn>=1.0\n",
            "  Downloading scikit_learn-1.0.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (24.8 MB)\n",
            "\u001b[K     |████████████████████████████████| 24.8 MB 67.6 MB/s \n",
            "\u001b[?25hCollecting scipy>=1.7.1\n",
            "  Downloading scipy-1.7.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (38.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 38.1 MB 1.3 MB/s \n",
            "\u001b[?25hCollecting six>=1.16.0\n",
            "  Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n",
            "Collecting threadpoolctl>=3.1.0\n",
            "  Downloading threadpoolctl-3.1.0-py3-none-any.whl (14 kB)\n",
            "Collecting tqdm>=4.64.0\n",
            "  Downloading tqdm-4.64.0-py2.py3-none-any.whl (78 kB)\n",
            "\u001b[K     |████████████████████████████████| 78 kB 7.7 MB/s \n",
            "\u001b[?25hCollecting xgboost>=1.6.1\n",
            "  Downloading xgboost-1.6.1-py3-none-manylinux2014_x86_64.whl (192.9 MB)\n",
            "\u001b[K     |████████████████████████████████| 192.9 MB 65 kB/s \n",
            "\u001b[?25hCollecting typing-extensions\n",
            "  Downloading typing_extensions-4.3.0-py3-none-any.whl (25 kB)\n",
            "Building wheels for collected packages: csa\n",
            "  Building wheel for csa (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for csa: filename=csa-1.0-py3-none-any.whl size=41307 sha256=7a64d5e05a1a3710dc45cb97558ec902cbfa1d1d9fdf710958d11063bd63ab36\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-d8x4wqcr/wheels/f8/a6/d2/85775e4ad67413a2107706e416bca603ec61caa57a672bd339\n",
            "Successfully built csa\n",
            "Installing collected packages: typing-extensions, six, pyparsing, numpy, threadpoolctl, scipy, pytz, python-dateutil, Pillow, packaging, kiwisolver, joblib, fonttools, cycler, xgboost, tqdm, scikit-learn, pandas, matplotlib, colorama, csa\n",
            "  Attempting uninstall: typing-extensions\n",
            "    Found existing installation: typing-extensions 4.1.1\n",
            "    Uninstalling typing-extensions-4.1.1:\n",
            "      Successfully uninstalled typing-extensions-4.1.1\n",
            "  Attempting uninstall: six\n",
            "    Found existing installation: six 1.15.0\n",
            "    Uninstalling six-1.15.0:\n",
            "      Successfully uninstalled six-1.15.0\n",
            "  Attempting uninstall: pyparsing\n",
            "    Found existing installation: pyparsing 3.0.9\n",
            "    Uninstalling pyparsing-3.0.9:\n",
            "      Successfully uninstalled pyparsing-3.0.9\n",
            "  Attempting uninstall: numpy\n",
            "    Found existing installation: numpy 1.21.6\n",
            "    Uninstalling numpy-1.21.6:\n",
            "      Successfully uninstalled numpy-1.21.6\n",
            "  Attempting uninstall: threadpoolctl\n",
            "    Found existing installation: threadpoolctl 3.1.0\n",
            "    Uninstalling threadpoolctl-3.1.0:\n",
            "      Successfully uninstalled threadpoolctl-3.1.0\n",
            "  Attempting uninstall: scipy\n",
            "    Found existing installation: scipy 1.4.1\n",
            "    Uninstalling scipy-1.4.1:\n",
            "      Successfully uninstalled scipy-1.4.1\n",
            "  Attempting uninstall: pytz\n",
            "    Found existing installation: pytz 2022.1\n",
            "    Uninstalling pytz-2022.1:\n",
            "      Successfully uninstalled pytz-2022.1\n",
            "  Attempting uninstall: python-dateutil\n",
            "    Found existing installation: python-dateutil 2.8.2\n",
            "    Uninstalling python-dateutil-2.8.2:\n",
            "      Successfully uninstalled python-dateutil-2.8.2\n",
            "  Attempting uninstall: Pillow\n",
            "    Found existing installation: Pillow 7.1.2\n",
            "    Uninstalling Pillow-7.1.2:\n",
            "      Successfully uninstalled Pillow-7.1.2\n",
            "  Attempting uninstall: packaging\n",
            "    Found existing installation: packaging 21.3\n",
            "    Uninstalling packaging-21.3:\n",
            "      Successfully uninstalled packaging-21.3\n",
            "  Attempting uninstall: kiwisolver\n",
            "    Found existing installation: kiwisolver 1.4.3\n",
            "    Uninstalling kiwisolver-1.4.3:\n",
            "      Successfully uninstalled kiwisolver-1.4.3\n",
            "  Attempting uninstall: joblib\n",
            "    Found existing installation: joblib 1.1.0\n",
            "    Uninstalling joblib-1.1.0:\n",
            "      Successfully uninstalled joblib-1.1.0\n",
            "  Attempting uninstall: cycler\n",
            "    Found existing installation: cycler 0.11.0\n",
            "    Uninstalling cycler-0.11.0:\n",
            "      Successfully uninstalled cycler-0.11.0\n",
            "  Attempting uninstall: xgboost\n",
            "    Found existing installation: xgboost 0.90\n",
            "    Uninstalling xgboost-0.90:\n",
            "      Successfully uninstalled xgboost-0.90\n",
            "  Attempting uninstall: tqdm\n",
            "    Found existing installation: tqdm 4.64.0\n",
            "    Uninstalling tqdm-4.64.0:\n",
            "      Successfully uninstalled tqdm-4.64.0\n",
            "  Attempting uninstall: scikit-learn\n",
            "    Found existing installation: scikit-learn 1.0.2\n",
            "    Uninstalling scikit-learn-1.0.2:\n",
            "      Successfully uninstalled scikit-learn-1.0.2\n",
            "  Attempting uninstall: pandas\n",
            "    Found existing installation: pandas 1.3.5\n",
            "    Uninstalling pandas-1.3.5:\n",
            "      Successfully uninstalled pandas-1.3.5\n",
            "  Attempting uninstall: matplotlib\n",
            "    Found existing installation: matplotlib 3.2.2\n",
            "    Uninstalling matplotlib-3.2.2:\n",
            "      Successfully uninstalled matplotlib-3.2.2\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "thinc 8.0.17 requires typing-extensions<4.2.0,>=3.7.4.1; python_version < \"3.8\", but you have typing-extensions 4.3.0 which is incompatible.\n",
            "spacy 3.3.1 requires typing-extensions<4.2.0,>=3.7.4; python_version < \"3.8\", but you have typing-extensions 4.3.0 which is incompatible.\n",
            "google-colab 1.0.0 requires six~=1.15.0, but you have six 1.16.0 which is incompatible.\n",
            "datascience 0.10.6 requires folium==0.2.1, but you have folium 0.8.3 which is incompatible.\n",
            "albumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\n",
            "Successfully installed Pillow-9.2.0 colorama-0.4.5 csa-1.0 cycler-0.11.0 fonttools-4.34.4 joblib-1.1.0 kiwisolver-1.4.3 matplotlib-3.5.2 numpy-1.21.6 packaging-21.3 pandas-1.3.5 pyparsing-3.0.9 python-dateutil-2.8.2 pytz-2022.1 scikit-learn-1.0.2 scipy-1.7.3 six-1.16.0 threadpoolctl-3.1.0 tqdm-4.64.0 typing-extensions-4.3.0 xgboost-1.6.1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "PIL",
                  "cycler",
                  "dateutil",
                  "kiwisolver",
                  "matplotlib",
                  "mpl_toolkits",
                  "numpy",
                  "six"
                ]
              }
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!git clone https://ntienvu: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@github.com/ntienvu/confident_sinkhorn_allocation\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4In7a4mE2p8G",
        "outputId": "33076031-a4fb-458e-8dfb-1bd868d8109d"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'confident_sinkhorn_allocation'...\n",
            "remote: Enumerating objects: 2001, done.\u001b[K\n",
            "remote: Counting objects: 100% (435/435), done.\u001b[K\n",
            "remote: Compressing objects: 100% (226/226), done.\u001b[K\n",
            "remote: Total 2001 (delta 270), reused 344 (delta 204), pack-reused 1566\u001b[K\n",
            "Receiving objects: 100% (2001/2001), 69.49 MiB | 13.68 MiB/s, done.\n",
            "Resolving deltas: 100% (629/629), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "sys.path.append('..')\n",
        "\n",
        "import numpy as np\n",
        "import os\n",
        "import argparse\n",
        "import logging\n",
        "import pickle\n",
        "from tqdm import tqdm\n",
        "import sklearn\n",
        "from algorithm.pseudo_labeling import Pseudo_Labeling\n",
        "#from confident_sinkhorn_allocation.algorithm.flexmatch import FlexMatch\n",
        "#from confident_sinkhorn_allocation.algorithm.ups import UPS\n",
        "from algorithm.csa import CSA\n",
        "from xgboost import XGBClassifier\n",
        "from sklearn.multioutput import MultiOutputClassifier\n",
        "\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "from utilities.utils import get_train_test_unlabeled,append_acc_early_termination\n",
        "from utilities.utils import get_train_test_unlabeled_for_multilabel\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "metadata": {
        "id": "Uy43buLIvVyv"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Multilabel datasets\n",
        "\n",
        "* yeast\n",
        "* emotions"
      ],
      "metadata": {
        "id": "rqfm-kfmClJA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset_name='emotions'\n",
        "path_to_file='confident_sinkhorn_allocation/all_data_multilabel.pickle'\n",
        "x_train,y_train, x_test, y_test, x_unlabeled=get_train_test_unlabeled_for_multilabel(dataset_name,path_to_file,random_state=0)\n",
        "\n"
      ],
      "metadata": {
        "id": "-HOYZmqnClT4"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "\n",
        "print(\"number of training points = \",y_train.shape[0])\n",
        "\n",
        "print(\"number of test points = \",y_test.shape[0])\n",
        "\n",
        "print(\"number of unlabelled points = \",x_unlabeled.shape[0])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VJcf96UTT_1I",
        "outputId": "8a7a7fd7-3a7d-48f2-b794-c6782db28b1b"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(266, 72)\n",
            "(266, 6)\n",
            "number of training points =  266\n",
            "number of test points =  60\n",
            "number of unlabelled points =  267\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Purely Supervised learning\n",
        "# Train an XGBoost model using on training data (labelled data)"
      ],
      "metadata": {
        "id": "8jHc6twUECW_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# this is the XGBoost model for multi-class classification\n",
        "param = {}\n",
        "param['booster'] = 'gbtree'\n",
        "param['objective'] = 'binary:logistic'\n",
        "param['verbosity'] = 0\n",
        "param['silent'] = 1\n",
        "param['seed'] = 0\n",
        "\n",
        "# create XGBoost instance with default hyper-parameters\n",
        "xgb=MultiOutputClassifier(XGBClassifier(**param,use_label_encoder=False))\n",
        "\n",
        "xgb.fit(x_train, y_train)\n",
        "\n",
        "# evaluate the performance on the test set\n",
        "y_test_pred = xgb.predict(x_test)      \n",
        "#supervised_learning_accuracy= np.round( accuracy_score(y_test_pred, y_test)*100, 2)# round to 2 digits xx.yy %\n",
        "\n",
        "prec=sklearn.metrics.precision_score(y_test, y_test_pred,average='samples')*100\n",
        "prec=np.round(prec,2) # round to 2 digits xx.yy %\n",
        "supervised_learning_accuracy=prec\n",
        "print('+++Test Acc: {:.2f}%'.format(supervised_learning_accuracy))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nQYIJtyAUjRc",
        "outputId": "c7d13121-d194-41d9-c9aa-c59315387119"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 68.33%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Perform Semi-supervised learning using Pseudo-labeling\n",
        "# Set a few hyperparameters for the model"
      ],
      "metadata": {
        "id": "sJus9ol7vV23"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numTrials=1\n",
        "numIters=5\n",
        "upper_threshold=0.8\n",
        "dataset_name='emotions'\n",
        "\n",
        "#======================================================= set multilabel classification here\n",
        "IsMultiLabel=True "
      ],
      "metadata": {
        "id": "egvG4QuLUVb1"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pseudo_labeling_model = Pseudo_Labeling(x_unlabeled,x_test,y_test, \n",
        "                num_iters=numIters,\n",
        "                upper_threshold=upper_threshold,\n",
        "                verbose = True,\n",
        "                IsMultiLabel=IsMultiLabel #========it is important to set IsMultiLabel=True\n",
        "                )\n",
        "\n",
        "pseudo_labeling_model.fit(x_train, y_train)\n",
        "        \n",
        "pseudo_labeling_accuracy=pseudo_labeling_model.test_acc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qlg10vE9VgMl",
        "outputId": "83bf160d-07bc-4857-c468-27a3f004903c"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "no of unlabelled data: 267 \t no of test data: 60\n",
            "===== Pseudo_Labeling\n",
            "==label_frequency without adjustment [ 73  66 117  71  83  81]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 20%|██        | 1/5 [00:17<01:11, 17.95s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 68.33%\n",
            "MaxPseudoPoint [14, 12, 22, 13, 16, 15]\n",
            "#augmented: [array([14, 12, 22, 13, 16, 15])]  no training data  345\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 40%|████      | 2/5 [00:22<00:30, 10.09s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 73.61%\n",
            "MaxPseudoPoint [8, 7, 12, 8, 9, 9]\n",
            "#augmented: [array([14, 12, 22, 13, 16, 15]), array([ 8,  7, 12,  8,  9,  9])]  no training data  394\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 60%|██████    | 3/5 [00:27<00:15,  7.66s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 73.89%\n",
            "MaxPseudoPoint [5, 4, 7, 5, 5, 5]\n",
            "#augmented: [array([14, 12, 22, 13, 16, 15]), array([ 8,  7, 12,  8,  9,  9]), array([5, 2, 7, 3, 3, 5])]  no training data  418\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 80%|████████  | 4/5 [00:32<00:06,  6.55s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 70.83%\n",
            "MaxPseudoPoint [3, 3, 4, 3, 3, 3]\n",
            "#augmented: [array([14, 12, 22, 13, 16, 15]), array([ 8,  7, 12,  8,  9,  9]), array([5, 2, 7, 3, 3, 5]), array([3, 0, 4, 0, 2, 3])]  no training data  430\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [00:37<00:00,  7.42s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 75.00%\n",
            "MaxPseudoPoint [2, 1, 2, 1, 2, 2]\n",
            "#augmented: [array([14, 12, 22, 13, 16, 15]), array([ 8,  7, 12,  8,  9,  9]), array([5, 2, 7, 3, 3, 5]), array([3, 0, 4, 0, 2, 3]), array([2, 1, 2, 1, 1, 2])]  no training data  439\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 74.44%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plot the comparison between Supervised Learning vs Pseudo-labeling"
      ],
      "metadata": {
        "id": "o_sBQhLiWEpv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#!python -m pip uninstall matplotlib\n",
        "#!pip install matplotlib==3.1.3\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# plot in the same axis\n",
        "\n",
        "supervised_learning_result=[ supervised_learning_accuracy ]*len(pseudo_labeling_accuracy)\n",
        "\n",
        "plt.figure(figsize=(8,5))\n",
        "plt.plot(np.arange(len(pseudo_labeling_accuracy)),\\\n",
        "         supervised_learning_result,'m:',linewidth=4,label=\"Supervised Learning\") \n",
        "plt.plot(pseudo_labeling_accuracy,'k-.',linewidth=4,label='Pseudo-labeling')\n",
        "\n",
        "plt.xlabel(\"Pseudo-labeling Iteration\",fontsize=14)\n",
        "plt.ylabel(\"Test Accuracy\",fontsize=14)\n",
        "\n",
        "plt.legend(fontsize=14)\n",
        "\n",
        "plt.title(\"Dataset = \" + dataset_name,fontsize=14 )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "d6vOdyqvWHWR",
        "outputId": "4d9791fc-8318-43eb-8fbb-97532e4e2a71"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found existing installation: matplotlib 3.5.2\n",
            "Uninstalling matplotlib-3.5.2:\n",
            "  Would remove:\n",
            "    /usr/local/lib/python3.7/dist-packages/matplotlib-3.5.2-py3.7-nspkg.pth\n",
            "    /usr/local/lib/python3.7/dist-packages/matplotlib-3.5.2.dist-info/*\n",
            "    /usr/local/lib/python3.7/dist-packages/matplotlib/*\n",
            "    /usr/local/lib/python3.7/dist-packages/mpl_toolkits/axes_grid/*\n",
            "    /usr/local/lib/python3.7/dist-packages/mpl_toolkits/axes_grid1/*\n",
            "    /usr/local/lib/python3.7/dist-packages/mpl_toolkits/axisartist/*\n",
            "    /usr/local/lib/python3.7/dist-packages/mpl_toolkits/mplot3d/*\n",
            "    /usr/local/lib/python3.7/dist-packages/mpl_toolkits/tests/*\n",
            "    /usr/local/lib/python3.7/dist-packages/pylab.py\n",
            "Proceed (y/n)? n\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting matplotlib==3.1.3\n",
            "  Downloading matplotlib-3.1.3-cp37-cp37m-manylinux1_x86_64.whl (13.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 13.1 MB 4.4 MB/s \n",
            "\u001b[?25hRequirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (0.11.0)\n",
            "Requirement already satisfied: numpy>=1.11 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (1.21.6)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (1.4.3)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (3.0.9)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib==3.1.3) (2.8.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib==3.1.3) (4.3.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib==3.1.3) (1.16.0)\n",
            "Installing collected packages: matplotlib\n",
            "  Attempting uninstall: matplotlib\n",
            "    Found existing installation: matplotlib 3.5.2\n",
            "    Uninstalling matplotlib-3.5.2:\n",
            "      Successfully uninstalled matplotlib-3.5.2\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "albumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\n",
            "Successfully installed matplotlib-3.1.3\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "matplotlib",
                  "mpl_toolkits"
                ]
              }
            }
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Dataset = emotions')"
            ]
          },
          "metadata": {},
          "execution_count": 9
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Run the proposed Confident Sinkhorn Allocation (CSA)"
      ],
      "metadata": {
        "id": "hycXGI6cX7IB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num_XGB_models=10\n",
        "confidence_choice='variance'\n",
        "\n",
        "csa_model = CSA(x_unlabeled,x_test,y_test, \n",
        "                num_iters=numIters,\n",
        "                confidence_choice=confidence_choice,\n",
        "                num_XGB_models=num_XGB_models,\n",
        "                verbose = True,\n",
        "                IsMultiLabel=IsMultiLabel #========it is important to set IsMultiLabel=True\n",
        "            )\n",
        "csa_model.fit(x_train, y_train)\n",
        "\n",
        "csa_accuracy=csa_model.test_acc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U5J8NWFsX-mz",
        "outputId": "ddc686ea-1c84-4b07-ac6a-139ff0a42d87"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "no of unlabelled data: 267 \t no of test data: 60\n",
            "number of used XGB models  M= 10\n",
            "===== CSA_variance\n",
            "==label_frequency without adjustment [ 73  66 117  71  83  81]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/5 [00:00<?, ?it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 68.33%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 20%|██        | 1/5 [03:15<13:03, 195.99s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  137  total num_points= 267\n",
            "#unlabel=267 #points/#classes=137/6=22.83 reg=10.00\n",
            "MaxPseudoPoint [14, 12, 22, 13, 16, 15]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0])]  len of training data  288\n",
            "+++Test Acc: 70.56%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 40%|████      | 2/5 [06:16<09:20, 186.80s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  118  total num_points= 245\n",
            "#unlabel=245 #points/#classes=118/6=19.67 reg=10.00\n",
            "MaxPseudoPoint [10, 9, 16, 10, 12, 11]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0])]  len of training data  304\n",
            "+++Test Acc: 71.94%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 60%|██████    | 3/5 [09:17<06:08, 184.21s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  114  total num_points= 229\n",
            "#unlabel=229 #points/#classes=114/6=19.00 reg=10.00\n",
            "MaxPseudoPoint [7, 7, 11, 7, 8, 8]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0]), array([ 0,  0, 11,  0,  0,  0])]  len of training data  315\n",
            "+++Test Acc: 71.67%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 80%|████████  | 4/5 [12:19<03:03, 183.31s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  99  total num_points= 218\n",
            "#unlabel=218 #points/#classes=99/6=16.50 reg=10.00\n",
            "MaxPseudoPoint [5, 4, 7, 5, 5, 5]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0]), array([ 0,  0, 11,  0,  0,  0]), array([0, 0, 7, 0, 0, 0])]  len of training data  322\n",
            "+++Test Acc: 69.44%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [15:22<00:00, 184.48s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  111  total num_points= 211\n",
            "#unlabel=211 #points/#classes=111/6=18.50 reg=10.00\n",
            "MaxPseudoPoint [3, 2, 4, 3, 3, 3]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0]), array([ 0,  0, 11,  0,  0,  0]), array([0, 0, 7, 0, 0, 0]), array([0, 0, 4, 0, 0, 0])]  len of training data  326\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 73.61%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plot the comparison between Supervised, Pseudo-labeling and CSA"
      ],
      "metadata": {
        "id": "Dqxm85MYYMex"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# plot in the same axis\n",
        "\n",
        "supervised_learning_result=[ supervised_learning_accuracy ]*len(pseudo_labeling_accuracy)\n",
        "\n",
        "plt.figure(figsize=(8,5))\n",
        "\n",
        "# Supervised Learning\n",
        "plt.plot(np.arange(len(pseudo_labeling_accuracy)),\\\n",
        "         supervised_learning_result,'m:',linewidth=4,label=\"Supervised Learning\") \n",
        "\n",
        "# Pseudo Labeling\n",
        "plt.plot(pseudo_labeling_accuracy,'k-.',linewidth=4,label='Pseudo-labeling')\n",
        "\n",
        "# CSA\n",
        "plt.plot(csa_accuracy,'r-',linewidth=4,label='CSA')\n",
        "\n",
        "plt.xlabel(\"Pseudo-labeling Iteration\",fontsize=14)\n",
        "plt.ylabel(\"Test Accuracy\",fontsize=14)\n",
        "\n",
        "plt.legend(fontsize=12)\n",
        "\n",
        "plt.title(\"Dataset = \" + dataset_name,fontsize=14 )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 372
        },
        "id": "35JXEyCHYMno",
        "outputId": "1cc172eb-7573-4a26-cac1-afb0bfbb0070"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Dataset = emotions')"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Run ablation study of CSA without ttest, using all data points, like the SLA paper"
      ],
      "metadata": {
        "id": "-osJbfAAZPi9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "confidence_choice=\"none\"\n",
        "\n",
        "# SLA model ~ CSA without ttest\n",
        "\n",
        "sla_model = CSA(x_unlabeled,x_test,y_test, \n",
        "                num_iters=numIters,\n",
        "                confidence_choice=confidence_choice,\n",
        "                num_XGB_models=num_XGB_models,\n",
        "                verbose = True,\n",
        "                IsMultiLabel=IsMultiLabel #========it is important to set IsMultiLabel=True\n",
        "            )\n",
        "sla_model.fit(x_train, y_train)\n",
        "\n",
        "sla_accuracy=sla_model.test_acc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bduQKvMiZWBi",
        "outputId": "34806c40-a571-44f6-a8b8-39af7978f450"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "no of unlabelled data: 267 \t no of test data: 60\n",
            "number of used XGB models  M= 10\n",
            "===== CSA_variance\n",
            "==label_frequency without adjustment [ 73  66 117  71  83  81]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/5 [00:00<?, ?it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 68.33%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 20%|██        | 1/5 [03:32<14:09, 212.29s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  133  total num_points= 267\n",
            "#unlabel=267 #points/#classes=133/6=22.17 reg=10.00\n",
            "MaxPseudoPoint [14, 12, 22, 13, 16, 15]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0])]  len of training data  288\n",
            "+++Test Acc: 68.33%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 40%|████      | 2/5 [06:47<10:06, 202.30s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  110  total num_points= 245\n",
            "#unlabel=245 #points/#classes=110/6=18.33 reg=10.00\n",
            "MaxPseudoPoint [10, 9, 16, 10, 12, 11]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0])]  len of training data  304\n",
            "+++Test Acc: 72.22%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 60%|██████    | 3/5 [10:09<06:43, 201.93s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  108  total num_points= 229\n",
            "#unlabel=229 #points/#classes=108/6=18.00 reg=10.00\n",
            "MaxPseudoPoint [7, 7, 11, 7, 8, 8]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0]), array([ 0,  0, 11,  0,  0,  0])]  len of training data  315\n",
            "+++Test Acc: 69.72%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r 80%|████████  | 4/5 [13:28<03:21, 201.01s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  103  total num_points= 218\n",
            "#unlabel=218 #points/#classes=103/6=17.17 reg=10.00\n",
            "MaxPseudoPoint [5, 4, 7, 5, 5, 5]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0]), array([ 0,  0, 11,  0,  0,  0]), array([0, 0, 7, 0, 0, 0])]  len of training data  322\n",
            "+++Test Acc: 69.17%\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5/5 [16:49<00:00, 201.85s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "num_points accepted=  104  total num_points= 211\n",
            "#unlabel=211 #points/#classes=104/6=17.33 reg=10.00\n",
            "MaxPseudoPoint [3, 2, 4, 3, 3, 3]\n",
            "#augmented: [array([ 0,  0, 22,  0,  0,  0]), array([ 0,  0, 16,  0,  0,  0]), array([ 0,  0, 11,  0,  0,  0]), array([0, 0, 7, 0, 0, 0]), array([0, 0, 4, 0, 0, 0])]  len of training data  326\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+++Test Acc: 73.06%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot in the same axis\n",
        "\n",
        "supervised_learning_result=[ supervised_learning_accuracy ]*len(pseudo_labeling_accuracy)\n",
        "\n",
        "plt.figure(figsize=(8,5))\n",
        "\n",
        "# Supervised Learning\n",
        "plt.plot(np.arange(len(pseudo_labeling_accuracy)),\\\n",
        "         supervised_learning_result,'m:',linewidth=4,label=\"Supervised Learning\") \n",
        "\n",
        "# Pseudo Labeling\n",
        "plt.plot(pseudo_labeling_accuracy,'k-.',linewidth=4,label='Pseudo-labeling')\n",
        "\n",
        "# SLA\n",
        "plt.plot(sla_accuracy,'b:',linewidth=4,label='SLA')\n",
        "\n",
        "# CSA\n",
        "plt.plot(csa_accuracy,'r-',linewidth=4,label='CSA')\n",
        "\n",
        "plt.xlabel(\"Pseudo-labeling Iteration\",fontsize=14)\n",
        "plt.ylabel(\"Test Accuracy\",fontsize=14)\n",
        "\n",
        "plt.legend(fontsize=12)\n",
        "\n",
        "plt.title(\"Dataset = \" + dataset_name,fontsize=14 )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 372
        },
        "id": "j-JijnqQbdmC",
        "outputId": "36f600aa-ae79-45d3-d5d1-5f07bd6a2d00"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Dataset = emotions')"
            ]
          },
          "metadata": {},
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}