ELM_Python_Iris.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ELM-Python-Iris.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 765
        },
        "id": "-hnm-k2KRFc7",
        "outputId": "33e38c5d-640a-4923-f40d-b0e4bf167a92"
      },
      "source": [
        "!pip install elm"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting elm\n",
            "  Downloading elm-0.1.3-py2.py3-none-any.whl (19 kB)\n",
            "Collecting deap==1.2.2\n",
            "  Downloading deap-1.2.2.tar.gz (936 kB)\n",
            "\u001b[K     |████████████████████████████████| 936 kB 16.6 MB/s \n",
            "\u001b[?25hCollecting optunity==1.1.1\n",
            "  Downloading Optunity-1.1.1.tar.gz (4.6 MB)\n",
            "\u001b[K     |████████████████████████████████| 4.6 MB 46.4 MB/s \n",
            "\u001b[?25hCollecting numpy==1.15.4\n",
            "  Downloading numpy-1.15.4-cp37-cp37m-manylinux1_x86_64.whl (13.8 MB)\n",
            "\u001b[K     |████████████████████████████████| 13.8 MB 20 kB/s \n",
            "\u001b[?25hBuilding wheels for collected packages: deap, optunity\n",
            "  Building wheel for deap (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for deap: filename=deap-1.2.2-cp37-cp37m-linux_x86_64.whl size=133813 sha256=8d1a90606d53d4b666a1594da959100a48d760c38c9e3c1790159a58b74738d0\n",
            "  Stored in directory: /root/.cache/pip/wheels/84/1b/38/94de55ab6f9b9b0e9ccb8d2e5fffadd76bf1cd1394f2890be4\n",
            "  Building wheel for optunity (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for optunity: filename=Optunity-1.1.1-py3-none-any.whl size=72031 sha256=a769d771a8d398318bf0a4887cea362a510c345d4d99742b93f9fb52fe7aa606\n",
            "  Stored in directory: /root/.cache/pip/wheels/0d/0e/31/a4763ff822a20f88a61dd3bb1c8b78a8f25c605392fe956d07\n",
            "Successfully built deap optunity\n",
            "Installing collected packages: optunity, numpy, deap, elm\n",
            "  Attempting uninstall: numpy\n",
            "    Found existing installation: numpy 1.19.5\n",
            "    Uninstalling numpy-1.19.5:\n",
            "      Successfully uninstalled numpy-1.19.5\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",
            "xarray 0.18.2 requires numpy>=1.17, but you have numpy 1.15.4 which is incompatible.\n",
            "tensorflow 2.6.0 requires numpy~=1.19.2, but you have numpy 1.15.4 which is incompatible.\n",
            "pyerfa 2.0.0 requires numpy>=1.17, but you have numpy 1.15.4 which is incompatible.\n",
            "pyarrow 3.0.0 requires numpy>=1.16.6, but you have numpy 1.15.4 which is incompatible.\n",
            "plotnine 0.6.0 requires numpy>=1.16.0, but you have numpy 1.15.4 which is incompatible.\n",
            "kapre 0.3.5 requires numpy>=1.18.5, but you have numpy 1.15.4 which is incompatible.\n",
            "jaxlib 0.1.71+cuda111 requires numpy>=1.18, but you have numpy 1.15.4 which is incompatible.\n",
            "jax 0.2.21 requires numpy>=1.18, but you have numpy 1.15.4 which is incompatible.\n",
            "datascience 0.10.6 requires folium==0.2.1, but you have folium 0.8.3 which is incompatible.\n",
            "astropy 4.3.1 requires numpy>=1.17, but you have numpy 1.15.4 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 deap-1.2.2 elm-0.1.3 numpy-1.15.4 optunity-1.1.1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "numpy"
                ]
              }
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DbwED7BdRX7u"
      },
      "source": [
        "import elm\n",
        "import numpy as np\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from  sklearn import  datasets\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "%matplotlib inline\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "iris = load_iris()\n",
        "X = iris['data']\n",
        "y = iris['target']\n",
        "names = iris['target_names']\n",
        "feature_names = iris['feature_names']"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 339
        },
        "id": "GaV5ORedRe2t",
        "outputId": "d611c101-676b-430d-c8de-b8ca826895c3"
      },
      "source": [
        "import matplotlib.pyplot as plt \n",
        "plt.style.use('ggplot')\n",
        "\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\n",
        "for target, target_name in enumerate(names):\n",
        "    X_plot = X[y == target]\n",
        "    ax1.plot(X_plot[:, 0], X_plot[:, 1], \n",
        "             linestyle='none', \n",
        "             marker='o', \n",
        "             label=target_name)\n",
        "ax1.set_xlabel(feature_names[0])\n",
        "ax1.set_ylabel(feature_names[1])\n",
        "ax1.axis('equal')\n",
        "ax1.legend();\n",
        "\n",
        "for target, target_name in enumerate(names):\n",
        "    X_plot = X[y == target]\n",
        "    ax2.plot(X_plot[:, 2], X_plot[:, 3], \n",
        "             linestyle='none', \n",
        "             marker='o', \n",
        "             label=target_name)\n",
        "ax2.set_xlabel(feature_names[2])\n",
        "ax2.set_ylabel(feature_names[3])\n",
        "ax2.axis('equal')\n",
        "ax2.legend();"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x432 with 2 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jSbt0OTLRtdQ",
        "outputId": "917ce87a-1bdd-4529-a869-749bcb3e56ea"
      },
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "scaler = StandardScaler()\n",
        "X_scaled = scaler.fit_transform(X)\n",
        "\n",
        "# Split the data set into training and testing\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=True)\n",
        "\n",
        "print(\"Training Shape\", X_train.shape, y_train.shape)\n",
        "print(\"Testing Shape\", X_test.shape, y_test.shape)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Shape (105, 4) (105,)\n",
            "Testing Shape (45, 4) (45,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YuPZqcESRxkf",
        "outputId": "8771c40e-a8e2-4f79-c5cf-a3552bfb4a2d"
      },
      "source": [
        "# load dataset\n",
        "iris = elm.read(\"/content/iris.data\")\n",
        "\n",
        "# create a classifier\n",
        "elmk = elm.ELMKernel()\n",
        "\n",
        "# search for best parameter for this dataset\n",
        "# define \"kfold\" cross-validation method, \"accuracy\" as a objective function\n",
        "# to be optimized and perform 10 searching steps.\n",
        "# best parameters will be saved inside 'elmk' object\n",
        "elmk.search_param(iris, cv=\"kfold\", of=\"accuracy\", eval=10)\n",
        "\n",
        "# split data in training and testing sets\n",
        "# use 80% of dataset to training and shuffle data before splitting\n",
        "tr_set, te_set = elm.split_sets(iris, training_percent=.8, perm=True)\n",
        "\n",
        "#train and test\n",
        "# results are Error objects\n",
        "tr_result = elmk.train(tr_set)\n",
        "te_result = elmk.test(te_set)\n",
        "\n",
        "print(te_result.get_accuracy)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "elmk\n",
            "##### Start search #####\n",
            "Kernel function:  rbf  best cv value:  0.9533333333333334\n",
            "Kernel function:  linear  best cv value:  0.9733333333333335\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deap/creator.py:141: RuntimeWarning: A class named 'FitnessMax' has already been created and it will be overwritten. Consider deleting previous creation of that class or rename it.\n",
            "  RuntimeWarning)\n",
            "/usr/local/lib/python3.7/dist-packages/deap/creator.py:141: RuntimeWarning: A class named 'Individual' has already been created and it will be overwritten. Consider deleting previous creation of that class or rename it.\n",
            "  RuntimeWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Kernel function:  poly  best cv value:  0.9800000000000002\n",
            "##### Search complete #####\n",
            "\n",
            "Regressor Parameters\n",
            "\n",
            "Regularization coefficient:  1.0831785970562564\n",
            "Kernel Function:  poly\n",
            "Kernel parameters:  [0.7367577554410882, 2.433039024446756]\n",
            "\n",
            "CV error:  0.9800000000000002\n",
            "\n",
            "<bound method Error.get_accuracy of <elm.mltools.Error object at 0x7f85693f7a50>>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pEtuBcCHYJnW"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PRwxUHxSYKl_",
        "outputId": "22dd5214-578c-45ed-8377-95d3993bbd9a"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from scipy.linalg import pinv2\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.model_selection import train_test_split\n",
        "%matplotlib inline\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "def relu(x):\n",
        "  return np.maximum(x, 0, x)\n",
        "\n",
        "def hidden_nodes(X):\n",
        "  G = np.dot(X, input_weights)\n",
        "  G = G + biases\n",
        "  H = relu(G)\n",
        "  return H\n",
        "\n",
        "def predict(X,output_weights):\n",
        "  out = hidden_nodes(X)\n",
        "  out = np.dot(out, output_weights)\n",
        "  return out\n",
        "\n",
        "iris = load_iris()\n",
        "X = iris['data']\n",
        "y = iris['target']\n",
        "names = iris['target_names']\n",
        "feature_names = iris['feature_names']\n",
        "\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "scaler = StandardScaler()\n",
        "X_scaled = scaler.fit_transform(X)\n",
        "\n",
        "# Split the data set into training and testing\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=True)\n",
        "\n",
        "print(\"Training Shape\", X_train.shape, y_train.shape)\n",
        "print(\"Testing Shape\", X_test.shape, y_test.shape)\n",
        "\n",
        "input_size = X_train.shape[1]\n",
        "hidden_size = 10\n",
        "\n",
        "input_weights = np.random.normal(size=[input_size,hidden_size])\n",
        "biases = np.random.normal(size=[hidden_size])\n",
        "\n",
        "output_weights = np.dot(pinv2(hidden_nodes(X_train)), y_train)\n",
        "\n",
        "prediction = predict(X_test, output_weights)\n",
        "correct = 0\n",
        "total = X_test.shape[0]\n",
        "\n",
        "for i in range(total):\n",
        "  predicted = np.round(prediction[i])\n",
        "  actual = y_test[i]\n",
        "  if predicted == actual:\n",
        "    correct += 1\n",
        "  else: \n",
        "    correct += 0\n",
        "\n",
        "accuracy = correct/total\n",
        "print('Accuracy for ', hidden_size, ' hidden nodes: ', accuracy)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Shape (105, 4) (105,)\n",
            "Testing Shape (45, 4) (45,)\n",
            "Accuracy for  10  hidden nodes:  1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x2bxDx4eZ2_P",
        "outputId": "d18c25e1-e2ef-45d8-f9be-88785cad571f"
      },
      "source": [
        "#For single sample prediction\n",
        "k=40\n",
        "pred = predict(X_test[k], output_weights)\n",
        "predicted = np.round(pred)\n",
        "if predicted == y_test[k]:\n",
        "  correct = 1\n",
        "else: \n",
        "  correct = 0\n",
        "\n",
        "print(\"Actual:\",y_test[k], \"Predicted:\", predicted)\n",
        "print(\"Accuracy:\", correct*100)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Actual: 2 Predicted: 2.0\n",
            "Accuracy: 100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0pJVjQLQltDh"
      },
      "source": [
        "import pickle\n",
        "\n",
        "pickle.dump(output_weights, open('elm_iris.pkl', 'wb'))"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "izjhmGeqni94",
        "outputId": "cce01af0-a5d5-4988-9b6f-92ea5a022b5c"
      },
      "source": [
        "# Deserialization of the file\n",
        "new_weights = pickle.load(open('elm_iris.pkl','rb'))\n",
        "\n",
        "#For single sample prediction\n",
        "k=17\n",
        "pred = predict(X_test[k], new_weights)\n",
        "predicted = np.round(pred)\n",
        "if predicted == y_test[k]:\n",
        "  correct = 1\n",
        "else: \n",
        "  correct = 0\n",
        "\n",
        "print(\"Actual:\",y_test[k], \"Predicted:\", predicted)\n",
        "print(\"Accuracy:\", correct*100)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Actual: 1 Predicted: 1.0\n",
            "Accuracy: 100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BffrHv-Rd9Jw"
      },
      "source": [
        "##http://wdm0006.github.io/sklearn-extensions/extreme_learning_machines.html"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EI9No_YAeav5",
        "outputId": "fc4fdc54-365a-482c-8b1d-f409404c92f0"
      },
      "source": [
        "!pip install sklearn_extensions"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting sklearn_extensions\n",
            "  Downloading sklearn-extensions-0.0.2.tar.gz (19 kB)\n",
            "Requirement already satisfied: numpy>=1.9.0 in /usr/local/lib/python3.7/dist-packages (from sklearn_extensions) (1.15.4)\n",
            "Requirement already satisfied: scikit-learn>=0.15 in /usr/local/lib/python3.7/dist-packages (from sklearn_extensions) (0.22.2.post1)\n",
            "Requirement already satisfied: scipy>=0.16.0 in /usr/local/lib/python3.7/dist-packages (from sklearn_extensions) (1.4.1)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.15->sklearn_extensions) (1.0.1)\n",
            "Building wheels for collected packages: sklearn-extensions\n",
            "  Building wheel for sklearn-extensions (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for sklearn-extensions: filename=sklearn_extensions-0.0.2-py2.py3-none-any.whl size=24578 sha256=ff8147156b70c6ee37fbd3f61b5b3525ceb9b8eaeee38b291dcde2ca630cbedb\n",
            "  Stored in directory: /root/.cache/pip/wheels/2b/a8/2c/b8896a9d6768f168eeaa54289c35bc36d6b1ba0c5b99c9cc84\n",
            "Successfully built sklearn-extensions\n",
            "Installing collected packages: sklearn-extensions\n",
            "Successfully installed sklearn-extensions-0.0.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VPvzMcqPd9NC",
        "outputId": "035c153f-d388-4397-84d3-a5e8b062c23d"
      },
      "source": [
        "import numpy as np\n",
        "from sklearn.datasets import make_moons, make_circles, make_classification\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "from sklearn_extensions.extreme_learning_machines.elm import GenELMClassifier\n",
        "from sklearn_extensions.extreme_learning_machines.random_layer import RBFRandomLayer, MLPRandomLayer\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "def make_classifiers():\n",
        "    \"\"\"\n",
        "\n",
        "    :return:\n",
        "    \"\"\"\n",
        "\n",
        "    names = [\"ELM(10,tanh)\", \"ELM(10,sinsq)\", \"ELM(10,tribas)\", \"ELM(hardlim)\", \"ELM(20,rbf(0.1))\"]\n",
        "\n",
        "    nh = 1000\n",
        "\n",
        "    # pass user defined transfer func\n",
        "    sinsq = (lambda x: np.power(np.sin(x), 2.0))\n",
        "    srhl_sinsq = MLPRandomLayer(n_hidden=nh, activation_func=sinsq)\n",
        "\n",
        "    # use internal transfer funcs\n",
        "    srhl_tanh = MLPRandomLayer(n_hidden=nh, activation_func='tanh')\n",
        "    srhl_tribas = MLPRandomLayer(n_hidden=nh, activation_func='tribas')\n",
        "    srhl_hardlim = MLPRandomLayer(n_hidden=nh, activation_func='hardlim')\n",
        "\n",
        "    # use gaussian RBF\n",
        "    srhl_rbf = RBFRandomLayer(n_hidden=nh*2, rbf_width=0.1, random_state=0)\n",
        "    \n",
        "    classifiers = [GenELMClassifier(hidden_layer=srhl_tanh),\n",
        "                   GenELMClassifier(hidden_layer=srhl_sinsq),\n",
        "                   GenELMClassifier(hidden_layer=srhl_tribas),\n",
        "                   GenELMClassifier(hidden_layer=srhl_hardlim),\n",
        "                   GenELMClassifier(hidden_layer=srhl_rbf)]\n",
        "\n",
        "    return names, classifiers\n",
        "\n",
        "\n",
        "if __name__ == '__main__':  \n",
        "        \n",
        "  #datasets = make_datasets()\n",
        "  names, classifiers = make_classifiers()\n",
        "   \n",
        "  # pre-process dataset, split into training and test part\n",
        "  iris = load_iris()\n",
        "  X = iris['data']\n",
        "  y = iris['target']\n",
        "  \n",
        "  scaler = StandardScaler()\n",
        "  X_scaled = scaler.fit_transform(X)\n",
        "\n",
        "  # Split the data set into training and testing\n",
        "  X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=True)\n",
        "  y_test = y_test.reshape(-1, )\n",
        "  y_train = y_train.reshape(-1, )\n",
        "\n",
        "  print(\"Training Shape\", X_train.shape, y_train.shape)\n",
        "  print(\"Testing Shape\", X_test.shape, y_test.shape)\n",
        "\n",
        "  # iterate over classifiers\n",
        "  for name, clf in zip(names, classifiers): \n",
        "    clf.fit(X_train, y_train)\n",
        "    score = clf.score(X_test, y_test)\n",
        "    print('Model %s score: %s' % (name, score))\n",
        "    "
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Shape (105, 4) (105,)\n",
            "Testing Shape (45, 4) (45,)\n",
            "Model ELM(10,tanh) score: 0.9333333333333333\n",
            "Model ELM(10,sinsq) score: 0.9111111111111111\n",
            "Model ELM(10,tribas) score: 0.9555555555555556\n",
            "Model ELM(hardlim) score: 0.9111111111111111\n",
            "Model ELM(20,rbf(0.1)) score: 0.9333333333333333\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 384
        },
        "id": "ZgiVjZiM3VVr",
        "outputId": "a004fe01-5dc5-4324-a5d2-ee556d167e4b"
      },
      "source": [
        "!pip install numpy --upgrade"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (1.15.4)\n",
            "Collecting numpy\n",
            "  Downloading numpy-1.21.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (15.7 MB)\n",
            "\u001b[K     |████████████████████████████████| 15.7 MB 194 kB/s \n",
            "\u001b[?25hInstalling collected packages: numpy\n",
            "  Attempting uninstall: numpy\n",
            "    Found existing installation: numpy 1.15.4\n",
            "    Uninstalling numpy-1.15.4:\n",
            "      Successfully uninstalled numpy-1.15.4\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",
            "tensorflow 2.6.0 requires numpy~=1.19.2, but you have numpy 1.21.2 which is incompatible.\n",
            "elm 0.1.3 requires numpy==1.15.4, but you have numpy 1.21.2 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 numpy-1.21.2\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "numpy"
                ]
              }
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DCc5zANicjMF",
        "outputId": "8bbb1469-963f-496f-a403-ce36d1dd21db"
      },
      "source": [
        "%%writefile elm.py\n",
        "\n",
        "import numpy as np\n",
        "np.random.seed(42)\n",
        "\n",
        "class ELM(object):  \n",
        "    \n",
        "  def __init__(self, inputSize, outputSize, hiddenSize):\n",
        "    \"\"\"\n",
        "    Initialize weight and bias between input layer and hidden layer\n",
        "    Parameters:\n",
        "    inputSize: int\n",
        "        The number of input layer dimensions or features in the training data\n",
        "    outputSize: int\n",
        "        The number of output layer dimensions\n",
        "    hiddenSize: int\n",
        "        The number of hidden layer dimensions        \n",
        "    \"\"\"    \n",
        "\n",
        "    self.inputSize = inputSize\n",
        "    self.outputSize = outputSize\n",
        "    self.hiddenSize = hiddenSize       \n",
        "    \n",
        "    # Initialize random weight with range [-0.5, 0.5]\n",
        "    self.weight = np.matrix(np.random.uniform(-0.5, 0.5, (self.hiddenSize, self.inputSize)))\n",
        "\n",
        "    # Initialize random bias with range [0, 1]\n",
        "    self.bias = np.matrix(np.random.uniform(0, 1, (1, self.hiddenSize)))\n",
        "    \n",
        "    self.H = 0\n",
        "    self.beta = 0\n",
        "\n",
        "  def sigmoid(self, x):\n",
        "    \"\"\"\n",
        "    Sigmoid activation function\n",
        "    \n",
        "    Parameters:\n",
        "    x: array-like or matrix\n",
        "        The value that the activation output will look for\n",
        "    Returns:      \n",
        "        The results of activation using sigmoid function\n",
        "    \"\"\"\n",
        "    return 1 / (1 + np.exp(-1 * x))\n",
        "\n",
        "  def predict(self, X):\n",
        "    \"\"\"\n",
        "    Predict the results of the training process using test data\n",
        "    Parameters:\n",
        "    X: array-like or matrix\n",
        "        Test data that will be used to determine output using ELM\n",
        "    Returns:\n",
        "        Predicted results or outputs from test data\n",
        "    \"\"\"\n",
        "    X = np.matrix(X)\n",
        "    y = self.sigmoid((X * self.weight.T) + self.bias) * self.beta\n",
        "\n",
        "    return y\n",
        "\n",
        "  def train(self, X, y):\n",
        "    \"\"\"\n",
        "    Extreme Learning Machine training process\n",
        "    Parameters:\n",
        "    X: array-like or matrix\n",
        "        Training data that contains the value of each feature\n",
        "    y: array-like or matrix\n",
        "        Training data that contains the value of the target (class)\n",
        "    Returns:\n",
        "        The results of the training process   \n",
        "    \"\"\"\n",
        "\n",
        "    X = np.matrix(X)\n",
        "    y = np.matrix(y)        \n",
        "    \n",
        "    # Calculate hidden layer output matrix (Hinit)\n",
        "    self.H = (X * self.weight.T) + self.bias\n",
        "\n",
        "    # Sigmoid activation function\n",
        "    self.H = self.sigmoid(self.H)\n",
        "\n",
        "    # Calculate the Moore-Penrose pseudoinverse matriks        \n",
        "    H_moore_penrose = np.linalg.inv(self.H.T * self.H) * self.H.T\n",
        "\n",
        "    # Calculate the output weight matrix beta\n",
        "    self.beta = H_moore_penrose * y\n",
        "\n",
        "    return self.H * self.beta"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing elm.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n_XoJr7Y1zm-",
        "outputId": "d4b45bd0-377c-415d-a545-cde83e200202"
      },
      "source": [
        "%%writefile test_elm_iris.py\n",
        "from elm import ELM\n",
        "import numpy as np\n",
        "from sklearn import datasets\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
        "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "# Create random classification datasets with 1000 samples\n",
        "iris = load_iris()\n",
        "X = iris['data']\n",
        "y = iris['target']\n",
        "names = iris['target_names']\n",
        "feature_names = iris['feature_names']\n",
        "\n",
        "scaler = StandardScaler()\n",
        "X_scaled = scaler.fit_transform(X)\n",
        "# Create instance of ELM object with 10 hidden neuron\n",
        "elm = ELM(X.shape[1], 1, 10)\n",
        "\n",
        "# Split the data set into training and testing\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=True)\n",
        "print(\"Training Shape\", X_train.shape, y_train.shape)\n",
        "print(\"Testing Shape\", X_test.shape, y_test.shape)\n",
        "\n",
        "# Train data\n",
        "elm.train(X_train,y_train.reshape(-1,1))\n",
        "\n",
        "# Make prediction from training process\n",
        "y_pred = elm.predict(X_test)\n",
        "y_pred = np.round(np.abs(y_pred))\n",
        "print(y_test, \"\\n\", y_pred.T)\n",
        "print('Accuracy: ', accuracy_score(y_test, y_pred))\n",
        "\n",
        "print(\"F1 Score: \", f1_score(y_test, y_pred, average=\"macro\"))\n",
        "print(\"Precision Score: \", precision_score(y_test, y_pred, average=\"macro\"))\n",
        "print(\"Recall Score: \", recall_score(y_test, y_pred, average=\"macro\")) \n",
        "print(classification_report(y_test, y_pred, target_names=names))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing test_elm_iris.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a9v-Qrln1_gf",
        "outputId": "02cd751e-4001-4f98-bada-1135883887f2"
      },
      "source": [
        "!python test_elm_iris.py"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Shape (120, 4) (120,)\n",
            "Testing Shape (30, 4) (30,)\n",
            "[0 1 1 0 2 1 2 0 0 2 1 0 2 1 1 0 1 1 0 0 1 1 1 0 2 1 0 0 1 2] \n",
            " [[0. 1. 1. 0. 2. 1. 2. 0. 0. 2. 1. 0. 2. 1. 1. 0. 1. 1. 0. 0. 1. 2. 1. 0.\n",
            "  2. 1. 0. 0. 1. 2.]]\n",
            "Accuracy:  0.9666666666666667\n",
            "F1 Score:  0.9610256410256409\n",
            "Precision Score:  0.9523809523809524\n",
            "Recall Score:  0.9743589743589745\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "      setosa       1.00      1.00      1.00        11\n",
            "  versicolor       1.00      0.92      0.96        13\n",
            "   virginica       0.86      1.00      0.92         6\n",
            "\n",
            "    accuracy                           0.97        30\n",
            "   macro avg       0.95      0.97      0.96        30\n",
            "weighted avg       0.97      0.97      0.97        30\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fzu3eUYudZFl",
        "outputId": "ac804636-ff3d-4738-c3b6-6a5735dbf492"
      },
      "source": [
        "%%writefile run_elm_iris.py\n",
        "import numpy as np\n",
        "from sklearn import datasets\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
        "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix\n",
        "from sklearn.metrics import roc_curve, auc, roc_auc_score\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "class ELM(object):  \n",
        "    \n",
        "  def __init__(self, inputSize, outputSize, hiddenSize):\n",
        "    \"\"\"\n",
        "    Initialize weight and bias between input layer and hidden layer\n",
        "    Parameters:\n",
        "    inputSize: int\n",
        "        The number of input layer dimensions or features in the training data\n",
        "    outputSize: int\n",
        "        The number of output layer dimensions\n",
        "    hiddenSize: int\n",
        "        The number of hidden layer dimensions        \n",
        "    \"\"\"    \n",
        "\n",
        "    self.inputSize = inputSize\n",
        "    self.outputSize = outputSize\n",
        "    self.hiddenSize = hiddenSize       \n",
        "    \n",
        "    # Initialize random weight with range [-0.5, 0.5]\n",
        "    self.weight = np.matrix(np.random.uniform(-0.5, 0.5, (self.hiddenSize, self.inputSize)))\n",
        "\n",
        "    # Initialize random bias with range [0, 1]\n",
        "    self.bias = np.matrix(np.random.uniform(0, 1, (1, self.hiddenSize)))\n",
        "    \n",
        "    self.H = 0\n",
        "    self.beta = 0\n",
        "\n",
        "  def sigmoid(self, x):\n",
        "    \"\"\"\n",
        "    Sigmoid activation function\n",
        "    \n",
        "    Parameters:\n",
        "    x: array-like or matrix\n",
        "        The value that the activation output will look for\n",
        "    Returns:      \n",
        "        The results of activation using sigmoid function\n",
        "    \"\"\"\n",
        "    return 1 / (1 + np.exp(-1 * x))\n",
        "\n",
        "  def predict(self, X):\n",
        "    \"\"\"\n",
        "    Predict the results of the training process using test data\n",
        "    Parameters:\n",
        "    X: array-like or matrix\n",
        "        Test data that will be used to determine output using ELM\n",
        "    Returns:\n",
        "        Predicted results or outputs from test data\n",
        "    \"\"\"\n",
        "    X = np.matrix(X)\n",
        "    y = self.sigmoid((X * self.weight.T) + self.bias) * self.beta\n",
        "\n",
        "    return y\n",
        "\n",
        "  def train(self, X, y):\n",
        "    \"\"\"\n",
        "    Extreme Learning Machine training process\n",
        "    Parameters:\n",
        "    X: array-like or matrix\n",
        "        Training data that contains the value of each feature\n",
        "    y: array-like or matrix\n",
        "        Training data that contains the value of the target (class)\n",
        "    Returns:\n",
        "        The results of the training process   \n",
        "    \"\"\"\n",
        "\n",
        "    X = np.matrix(X)\n",
        "    y = np.matrix(y)        \n",
        "    \n",
        "    # Calculate hidden layer output matrix (Hinit)\n",
        "    self.H = (X * self.weight.T) + self.bias\n",
        "\n",
        "    # Sigmoid activation function\n",
        "    self.H = self.sigmoid(self.H)\n",
        "\n",
        "    # Calculate the Moore-Penrose pseudoinverse matriks        \n",
        "    H_moore_penrose = np.linalg.inv(self.H.T * self.H) * self.H.T\n",
        "\n",
        "    # Calculate the output weight matrix beta\n",
        "    self.beta = H_moore_penrose * y\n",
        "\n",
        "    return self.H * self.beta\n",
        "\n",
        "def cm_analysis(y_true, y_pred, labels, ymap=None, figsize=(10,10)):\n",
        "  \"\"\"\n",
        "  Generate matrix plot of confusion matrix with pretty annotations.\n",
        "  The plot image is saved to disk.\n",
        "  args: \n",
        "    y_true:    true label of the data, with shape (nsamples,)\n",
        "    y_pred:    prediction of the data, with shape (nsamples,)\n",
        "    filename:  filename of figure file to save\n",
        "    labels:    string array, name the order of class labels in the confusion matrix.\n",
        "                use `clf.classes_` if using scikit-learn models.\n",
        "                with shape (nclass,).\n",
        "    ymap:      dict: any -> string, length == nclass.\n",
        "                if not None, map the labels & ys to more understandable strings.\n",
        "                Caution: original y_true, y_pred and labels must align.\n",
        "    figsize:   the size of the figure plotted.\n",
        "  \"\"\"\n",
        "  if ymap is not None:\n",
        "      y_pred = [ymap[yi] for yi in y_pred]\n",
        "      y_true = [ymap[yi] for yi in y_true]\n",
        "      labels = [ymap[yi] for yi in labels]\n",
        "  cm = confusion_matrix(y_true, y_pred)\n",
        "  cm_sum = np.sum(cm, axis=1, keepdims=True)\n",
        "  cm_perc = cm / cm_sum.astype(float) * 100\n",
        "  annot = np.empty_like(cm).astype(str)\n",
        "  nrows, ncols = cm.shape\n",
        "  for i in range(nrows):\n",
        "      for j in range(ncols):\n",
        "          c = cm[i, j]\n",
        "          p = cm_perc[i, j]\n",
        "          if i == j:\n",
        "              s = cm_sum[i]\n",
        "              annot[i, j] = '%.1f%%\\n%d/%d' % (p, c, s)\n",
        "          elif c == 0:\n",
        "              annot[i, j] = ''\n",
        "          else:\n",
        "              annot[i, j] = '%.1f%%\\n%d' % (p, c)\n",
        "  \n",
        "  cm = pd.DataFrame(cm, index=labels, columns=labels)\n",
        "  cm.index.name = 'Actual'\n",
        "  cm.columns.name = 'Predicted'\n",
        "  fig, ax = plt.subplots(figsize=figsize)\n",
        "  sns.heatmap(cm, annot=annot, cmap=\"YlGnBu\", fmt='', ax=ax, linewidths=.5)\n",
        "  #plt.savefig(filename)\n",
        "  plt.show()\n",
        "\n",
        "# Create random classification datasets with 1000 samples\n",
        "iris = load_iris()\n",
        "X = iris['data']\n",
        "y = iris['target']\n",
        "names = iris['target_names']\n",
        "feature_names = iris['feature_names']\n",
        "\n",
        "scaler = StandardScaler()\n",
        "X_scaled = scaler.fit_transform(X)\n",
        "# Create instance of ELM object with 10 hidden neuron\n",
        "elm = ELM(X.shape[1], 1, 10)\n",
        "\n",
        "# Split the data set into training and testing\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=True)\n",
        "print(\"Training Shape\", X_train.shape, y_train.shape)\n",
        "print(\"Testing Shape\", X_test.shape, y_test.shape)\n",
        "\n",
        "# Train data\n",
        "elm.train(X_train,y_train.reshape(-1,1))\n",
        "\n",
        "# Make prediction from training process\n",
        "y_pred = elm.predict(X_test)\n",
        "y_pred = np.round(np.abs(y_pred))\n",
        "print(y_test, \"\\n\", y_pred.T)\n",
        "\n",
        "print(\"\\nAccuracy: \", accuracy_score(y_test, y_pred))\n",
        "print(\"F1 Score: \", f1_score(y_test, y_pred, average=\"macro\"))\n",
        "print(\"Precision Score: \", precision_score(y_test, y_pred, average=\"macro\"))\n",
        "print(\"Recall Score: \", recall_score(y_test, y_pred, average=\"macro\")) \n",
        "print(\"\\n\", classification_report(y_test, y_pred, target_names=names))\n",
        "\n",
        "cm_analysis(y_test, y_pred, names, ymap=None, figsize=(6,6))\n",
        "cm = confusion_matrix(y_test, y_pred, normalize='all')\n",
        "cmd = ConfusionMatrixDisplay(cm, display_labels=names)\n",
        "cmd.plot()\n",
        "cmd.ax_.set(xlabel='Predicted', ylabel='True')\n",
        "#plt.savefig(\"Confusion_Matrix.png\")"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting run_elm_iris.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0aRjWJ2vzHsQ"
      },
      "source": [
        "%matplotlib inline"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 756
        },
        "id": "7dQAqsZRerQD",
        "outputId": "b3c7a13e-407c-4e4e-e851-c45e1a4bfd55"
      },
      "source": [
        "%run run_elm_iris.py"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Shape (120, 4) (120,)\n",
            "Testing Shape (30, 4) (30,)\n",
            "[0 1 1 0 2 1 2 0 0 2 1 0 2 1 1 0 1 1 0 0 1 1 1 0 2 1 0 0 1 2] \n",
            " [[0. 1. 1. 0. 2. 1. 2. 0. 0. 2. 1. 0. 2. 1. 1. 0. 1. 1. 0. 0. 1. 2. 1. 0.\n",
            "  2. 1. 0. 0. 1. 2.]]\n",
            "\n",
            "Accuracy:  0.9666666666666667\n",
            "F1 Score:  0.9610256410256409\n",
            "Precision Score:  0.9523809523809524\n",
            "Recall Score:  0.9743589743589745\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "      setosa       1.00      1.00      1.00        11\n",
            "  versicolor       1.00      0.92      0.96        13\n",
            "   virginica       0.86      1.00      0.92         6\n",
            "\n",
            "    accuracy                           0.97        30\n",
            "   macro avg       0.95      0.97      0.96        30\n",
            "weighted avg       0.97      0.97      0.97        30\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uS5RjKtx4evq",
        "outputId": "2b305020-16f5-40f2-e126-5bbd3f450bd6"
      },
      "source": [
        "#https://hpelm.readthedocs.io/en/latest/\n",
        "!pip install git+https://github.com/akusok/hpelm"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting git+https://github.com/akusok/hpelm\n",
            "  Cloning https://github.com/akusok/hpelm to /tmp/pip-req-build-9o847hlk\n",
            "  Running command git clone -q https://github.com/akusok/hpelm /tmp/pip-req-build-9o847hlk\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from hpelm==1.0.9) (1.21.2)\n",
            "Requirement already satisfied: scipy>=0.12 in /usr/local/lib/python3.7/dist-packages (from hpelm==1.0.9) (1.4.1)\n",
            "Requirement already satisfied: tables in /usr/local/lib/python3.7/dist-packages (from hpelm==1.0.9) (3.4.4)\n",
            "Requirement already satisfied: fasteners in /usr/local/lib/python3.7/dist-packages (from hpelm==1.0.9) (0.16.3)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from hpelm==1.0.9) (1.15.0)\n",
            "Requirement already satisfied: nose in /usr/local/lib/python3.7/dist-packages (from hpelm==1.0.9) (1.3.7)\n",
            "Requirement already satisfied: numexpr>=2.5.2 in /usr/local/lib/python3.7/dist-packages (from tables->hpelm==1.0.9) (2.7.3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 704
        },
        "id": "A3CwNV7yJfq2",
        "outputId": "78eed809-54db-4725-8aaf-9169c3969adf"
      },
      "source": [
        "import warnings\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.datasets import load_iris\n",
        "from sklearn.model_selection import train_test_split\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from hpelm import ELM\n",
        "from mlxtend.plotting import plot_confusion_matrix\n",
        "from scipy import ndimage\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
        "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report, confusion_matrix\n",
        "from sklearn.metrics import roc_curve, auc, roc_auc_score\n",
        "%matplotlib inline\n",
        "\n",
        "np.random.seed(42)\n",
        "\n",
        "def cm_analysis(y_true, y_pred, labels, ymap=None, figsize=(10,10)):\n",
        "  \"\"\"\n",
        "  Generate matrix plot of confusion matrix with pretty annotations.\n",
        "  The plot image is saved to disk.\n",
        "  args: \n",
        "    y_true:    true label of the data, with shape (nsamples,)\n",
        "    y_pred:    prediction of the data, with shape (nsamples,)\n",
        "    filename:  filename of figure file to save\n",
        "    labels:    string array, name the order of class labels in the confusion matrix.\n",
        "                use `clf.classes_` if using scikit-learn models.\n",
        "                with shape (nclass,).\n",
        "    ymap:      dict: any -> string, length == nclass.\n",
        "                if not None, map the labels & ys to more understandable strings.\n",
        "                Caution: original y_true, y_pred and labels must align.\n",
        "    figsize:   the size of the figure plotted.\n",
        "  \"\"\"\n",
        "  if ymap is not None:\n",
        "      y_pred = [ymap[yi] for yi in y_pred]\n",
        "      y_true = [ymap[yi] for yi in y_true]\n",
        "      labels = [ymap[yi] for yi in labels]\n",
        "  cm = confusion_matrix(y_true, y_pred, normalize='all')\n",
        "  cm_sum = np.sum(cm, axis=1, keepdims=True)\n",
        "  cm_perc = cm / cm_sum.astype(float) * 100\n",
        "  annot = np.empty_like(cm).astype(str)\n",
        "  nrows, ncols = cm.shape\n",
        "  for i in range(nrows):\n",
        "      for j in range(ncols):\n",
        "          c = cm[i, j]\n",
        "          p = cm_perc[i, j]\n",
        "          if i == j:\n",
        "              s = cm_sum[i]\n",
        "              annot[i, j] = '%.1f%%\\n%d/%d' % (p, c, s)\n",
        "          elif c == 0:\n",
        "              annot[i, j] = ''\n",
        "          else:\n",
        "              annot[i, j] = '%.1f%%\\n%d' % (p, c)\n",
        "  \n",
        "  cm = pd.DataFrame(cm, index=labels, columns=labels)\n",
        "  cm.index.name = 'Actual'\n",
        "  cm.columns.name = 'Predicted'\n",
        "  fig, ax = plt.subplots(figsize=figsize)\n",
        "  sns.heatmap(cm, annot=annot, cmap=\"YlGnBu\", fmt='', ax=ax, linewidths=.5)\n",
        "  #plt.savefig(filename)\n",
        "  plt.show()\n",
        "\n",
        "\n",
        "# Threshold value for classification (<= negative, > positive)\n",
        "THRESHOLD = 0.5\n",
        "\n",
        "# Create random classification datasets with 1000 samples\n",
        "iris = load_iris()\n",
        "X = iris['data']\n",
        "y = iris['target']\n",
        "names = iris['target_names']\n",
        "feature_names = iris['feature_names']\n",
        "\n",
        "scaler = StandardScaler()\n",
        "X_scaled = scaler.fit_transform(X)\n",
        "\n",
        "# Create ELM\n",
        "elm = ELM(4, 1)\n",
        "elm.add_neurons(10, 'sigm')\n",
        "elm.add_neurons(9, 'lin')\n",
        "\n",
        "# Split the data set into training and testing\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.1, random_state=True)\n",
        "print(\"Training Shape\", X_train.shape, y_train.shape)\n",
        "print(\"Testing Shape\", X_test.shape, y_test.shape)\n",
        "\n",
        "# Train data\n",
        "with warnings.catch_warnings():\n",
        "  warnings.simplefilter(\"ignore\")\n",
        "  elm.train(X_train, y_train)\n",
        "  y_pred = elm.predict(X_test)\n",
        "  y_pred = np.round(np.abs(y_pred))\n",
        "  y_pred = np.array(y_pred)\n",
        "  y_pred = np.where(y_pred >= 2, 2, y_pred)\n",
        "\n",
        "print('\\nAccuracy: ', accuracy_score(y_test, y_pred))\n",
        "print(\"F1 Score: \", f1_score(y_test, y_pred, average=\"macro\"))\n",
        "print(\"Precision Score: \", precision_score(y_test, y_pred, average=\"macro\"))\n",
        "print(\"Recall Score: \", recall_score(y_test, y_pred, average=\"macro\")) \n",
        "print(\"\\n\",classification_report(y_test, y_pred, target_names=names))\n",
        "\n",
        "cm_analysis(y_test, y_pred, names, ymap=None, figsize=(6,6))"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Shape (135, 4) (135,)\n",
            "Testing Shape (15, 4) (15,)\n",
            "\n",
            "Accuracy:  1.0\n",
            "F1 Score:  1.0\n",
            "Precision Score:  1.0\n",
            "Recall Score:  1.0\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "      setosa       1.00      1.00      1.00         5\n",
            "  versicolor       1.00      1.00      1.00         6\n",
            "   virginica       1.00      1.00      1.00         4\n",
            "\n",
            "    accuracy                           1.00        15\n",
            "   macro avg       1.00      1.00      1.00        15\n",
            "weighted avg       1.00      1.00      1.00        15\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}