ANFIS_(updated).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/farahani-mhmm/hazm/blob/master/ANFIS_(updated).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color='red'> Install Modules </font>"
      ],
      "metadata": {
        "id": "Y9Ofo65RoQPW"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "T4e5cNrOWA6E",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 220
        },
        "outputId": "f38e1b24-c9d7-4525-b90e-b4b8f15e1877"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-50503400fe07>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mw\u001b[0m\u001b[0;31m# pip install tensorflow\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;31m# # pip install anfis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# pip install numpy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# pip install matplotlib\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'w' is not defined"
          ]
        }
      ],
      "source": [
        "w# pip install tensorflow\n",
        "# # pip install anfis\n",
        "# pip install numpy\n",
        "# pip install matplotlib"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!git clone https://github.com/gregorLen/AnfisTensorflow2.0"
      ],
      "metadata": {
        "id": "iAXGzAtoJbnL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "58193275-35d5-4fa5-a4a2-bec97d1d6871"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'AnfisTensorflow2.0'...\n",
            "remote: Enumerating objects: 3029, done.\u001b[K\n",
            "remote: Counting objects: 100% (25/25), done.\u001b[K\n",
            "remote: Compressing objects: 100% (10/10), done.\u001b[K\n",
            "remote: Total 3029 (delta 19), reused 15 (delta 15), pack-reused 3004\u001b[K\n",
            "Receiving objects: 100% (3029/3029), 9.44 MiB | 23.40 MiB/s, done.\n",
            "Resolving deltas: 100% (550/550), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pwd"
      ],
      "metadata": {
        "id": "b3Lj2HmRLBmN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6f6b26bc-26fc-478c-88f6-0adc8945a0dc"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os"
      ],
      "metadata": {
        "id": "XNlosOKDLsJX"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.chdir(\"AnfisTensorflow2.0\")"
      ],
      "metadata": {
        "id": "hCeMINNqL0kl"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cd AnfisTensorflow2.0 "
      ],
      "metadata": {
        "id": "bLHMZ4UwJnw9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b1bed3d-e4fc-4c25-c2bd-9f474d891009"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/bin/bash: line 0: cd: AnfisTensorflow2.0: No such file or directory\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!python run.py"
      ],
      "metadata": {
        "id": "of4qarRtMMCT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb05d89f-fc28-49f8-ea15-849b80a5919c"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/AnfisTensorflow2.0/run.py:38: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
            "  plt.style.use('seaborn')                # default / ggplot / seaborn\n",
            "Epoch 1/20\n",
            "30/30 [==============================] - 2s 18ms/step - loss: 4.1760 - val_loss: 3.4974\n",
            "Epoch 2/20\n",
            "30/30 [==============================] - 0s 6ms/step - loss: 3.7542 - val_loss: 3.1325\n",
            "Epoch 3/20\n",
            "30/30 [==============================] - 0s 7ms/step - loss: 3.3726 - val_loss: 2.8005\n",
            "Epoch 4/20\n",
            "30/30 [==============================] - 0s 6ms/step - loss: 3.0224 - val_loss: 2.5016\n",
            "Epoch 5/20\n",
            "30/30 [==============================] - 0s 7ms/step - loss: 2.7034 - val_loss: 2.2295\n",
            "Epoch 6/20\n",
            "30/30 [==============================] - 0s 6ms/step - loss: 2.4102 - val_loss: 1.9831\n",
            "Epoch 7/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 2.1437 - val_loss: 1.7509\n",
            "Epoch 8/20\n",
            "30/30 [==============================] - 0s 4ms/step - loss: 1.8961 - val_loss: 1.5377\n",
            "Epoch 9/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 1.6658 - val_loss: 1.3422\n",
            "Epoch 10/20\n",
            "30/30 [==============================] - 0s 4ms/step - loss: 1.4512 - val_loss: 1.1642\n",
            "Epoch 11/20\n",
            "30/30 [==============================] - 0s 4ms/step - loss: 1.2551 - val_loss: 0.9932\n",
            "Epoch 12/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 1.0694 - val_loss: 0.8391\n",
            "Epoch 13/20\n",
            "30/30 [==============================] - 0s 6ms/step - loss: 0.8988 - val_loss: 0.6977\n",
            "Epoch 14/20\n",
            "30/30 [==============================] - 0s 4ms/step - loss: 0.7430 - val_loss: 0.5670\n",
            "Epoch 15/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 0.6001 - val_loss: 0.4477\n",
            "Epoch 16/20\n",
            "30/30 [==============================] - 0s 6ms/step - loss: 0.4700 - val_loss: 0.3436\n",
            "Epoch 17/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 0.3548 - val_loss: 0.2572\n",
            "Epoch 18/20\n",
            "30/30 [==============================] - 0s 6ms/step - loss: 0.2588 - val_loss: 0.1872\n",
            "Epoch 19/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 0.1842 - val_loss: 0.1356\n",
            "Epoch 20/20\n",
            "30/30 [==============================] - 0s 5ms/step - loss: 0.1353 - val_loss: 0.1037\n",
            "Time to fit: 4.85 seconds\n",
            "50/50 [==============================] - 0s 1ms/step\n",
            "Figure(800x1000)\n",
            "Figure(800x600)\n",
            "Model: \"myanfis\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " inputLayer (InputLayer)        [(32, 2)]            0           []                               \n",
            "                                                                                                  \n",
            " fuzzyLayer (FuzzyLayer)        (32, 3, 2)           12          ['inputLayer[0][0]']             \n",
            "                                                                                                  \n",
            " ruleLayer (RuleLayer)          (32, 9)              0           ['fuzzyLayer[0][0]']             \n",
            "                                                                                                  \n",
            " normLayer (NormLayer)          (32, 9)              0           ['ruleLayer[0][0]']              \n",
            "                                                                                                  \n",
            " defuzzLayer (DefuzzLayer)      (32, 9)              27          ['normLayer[0][0]',              \n",
            "                                                                  'inputLayer[0][0]']             \n",
            "                                                                                                  \n",
            " sumLayer (SummationLayer)      (32, 1)              0           ['defuzzLayer[0][0]']            \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 39\n",
            "Trainable params: 39\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color='red'>Import Modules </font>"
      ],
      "metadata": {
        "id": "b8TVuI2lltgR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Kullanılacak olan modelin içerisinde bulunduğu script\n",
        "from Models import myanfis\n",
        "\n",
        "# Veri işlemeri için kullanılacak olan kütüphane\n",
        "import pandas as pd\n",
        "\n",
        "# sayısal işlemler için kullanılan kütüphane\n",
        "import numpy\n",
        "\n",
        "# Model için gerekli bir kütüphane\n",
        "import sys\n",
        "sys.maxsize\n",
        "\n",
        "# KFold \n",
        "from sklearn.model_selection import KFold\n",
        "\n",
        "# Scaler\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "\n",
        "# Model için gerekli olan makine öğrenmesi kütüphanesi\n",
        "import tensorflow as tf\n"
      ],
      "metadata": {
        "id": "WRDXJddiNfyR"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#df = pd.read_csv(\"/content/AnfisTensorflow2.0/winequality-red.csv\")"
      ],
      "metadata": {
        "id": "a8Z63iJSO-bo"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df = pd.read_csv(\"/content/AnfisTensorflow2.0/user_profiles - Copy.csv\")"
      ],
      "metadata": {
        "id": "4cHEzOsfPrk2"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "6018330d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "e2d393cb-9638-4d55-e2b9-b77068cca7d0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "       id  favourites_count  followers_count  number_of_tweets\n",
              "0  103007               430              141             20912\n",
              "1  106161               107               48              1321\n",
              "2  106757              2863              860             24165\n",
              "3  106965               181               85              1356\n",
              "4  108525              5964             1315             23808"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-4f4ef529-89f6-4197-85f6-aadfefd2aa1c\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>id</th>\n",
              "      <th>favourites_count</th>\n",
              "      <th>followers_count</th>\n",
              "      <th>number_of_tweets</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>103007</td>\n",
              "      <td>430</td>\n",
              "      <td>141</td>\n",
              "      <td>20912</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>106161</td>\n",
              "      <td>107</td>\n",
              "      <td>48</td>\n",
              "      <td>1321</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>106757</td>\n",
              "      <td>2863</td>\n",
              "      <td>860</td>\n",
              "      <td>24165</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>106965</td>\n",
              "      <td>181</td>\n",
              "      <td>85</td>\n",
              "      <td>1356</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>108525</td>\n",
              "      <td>5964</td>\n",
              "      <td>1315</td>\n",
              "      <td>23808</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-4f4ef529-89f6-4197-85f6-aadfefd2aa1c')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-4f4ef529-89f6-4197-85f6-aadfefd2aa1c button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-4f4ef529-89f6-4197-85f6-aadfefd2aa1c');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "# veriye bir bakış attık\n",
        "df.head()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.describe()"
      ],
      "metadata": {
        "id": "NuQY-IBPPxnt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "83d5b193-395e-4112-b809-ff0ee0f32d31"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                 id  favourites_count  followers_count  number_of_tweets\n",
              "count  4.820000e+02        482.000000       482.000000        482.000000\n",
              "mean   7.224085e+05       3666.238589      1202.344398      13378.099585\n",
              "std    1.119783e+06       9976.059714      4479.876463      23362.978904\n",
              "min    1.030070e+05          0.000000         1.000000          1.000000\n",
              "25%    3.133500e+05        118.500000       160.000000       1443.000000\n",
              "50%    5.395750e+05        698.500000       348.500000       4854.500000\n",
              "75%    7.710885e+05       2788.000000       857.250000      15549.000000\n",
              "max    9.431609e+06     112605.000000     83722.000000     241757.000000"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-471f9278-f8cf-45d7-9212-3e8624129a89\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>id</th>\n",
              "      <th>favourites_count</th>\n",
              "      <th>followers_count</th>\n",
              "      <th>number_of_tweets</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>4.820000e+02</td>\n",
              "      <td>482.000000</td>\n",
              "      <td>482.000000</td>\n",
              "      <td>482.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>7.224085e+05</td>\n",
              "      <td>3666.238589</td>\n",
              "      <td>1202.344398</td>\n",
              "      <td>13378.099585</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>1.119783e+06</td>\n",
              "      <td>9976.059714</td>\n",
              "      <td>4479.876463</td>\n",
              "      <td>23362.978904</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>1.030070e+05</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>1.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>3.133500e+05</td>\n",
              "      <td>118.500000</td>\n",
              "      <td>160.000000</td>\n",
              "      <td>1443.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>5.395750e+05</td>\n",
              "      <td>698.500000</td>\n",
              "      <td>348.500000</td>\n",
              "      <td>4854.500000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>7.710885e+05</td>\n",
              "      <td>2788.000000</td>\n",
              "      <td>857.250000</td>\n",
              "      <td>15549.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>9.431609e+06</td>\n",
              "      <td>112605.000000</td>\n",
              "      <td>83722.000000</td>\n",
              "      <td>241757.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-471f9278-f8cf-45d7-9212-3e8624129a89')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-471f9278-f8cf-45d7-9212-3e8624129a89 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-471f9278-f8cf-45d7-9212-3e8624129a89');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "minmaxScaler = MinMaxScaler()\n",
        "df2 = df.copy()\n",
        "\n",
        "df2['favourites_count'] = minmaxScaler.fit_transform(df2[['favourites_count']])\n",
        "df2['number_of_tweets'] = minmaxScaler.fit_transform(df2[['number_of_tweets']])\n",
        "df2['followers_count'] = minmaxScaler.fit_transform(df2[['followers_count']])"
      ],
      "metadata": {
        "id": "UT6zuQioP06F"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#training\n",
        "X = df2.iloc[:-199,[1,7]]\n",
        "Y = df2.iloc[:-199,-1]\n",
        "\n",
        "# validation\n",
        "x = df2.iloc[-199:,[1,7]]\n",
        "y = df2.iloc[-199:,-1]"
      ],
      "metadata": {
        "id": "8lEnkK95P6UH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 383
        },
        "outputId": "b72e5509-9713-427b-942a-9d0eb88b4188"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-e7ba3ad914b9>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#training\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m199\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mY\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m199\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# validation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    959\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_is_scalar_access\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    960\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtakeable\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_takeable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 961\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_tuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    962\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    963\u001b[0m             \u001b[0;31m# we by definition only have the 0th axis\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_getitem_tuple\u001b[0;34m(self, tup)\u001b[0m\n\u001b[1;32m   1459\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_getitem_tuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtup\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1461\u001b[0;31m         \u001b[0mtup\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_tuple_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1462\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0msuppress\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mIndexingError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1463\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_lowerdim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_validate_tuple_indexer\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    767\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    768\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 769\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_key\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    770\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    771\u001b[0m                 raise ValueError(\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_validate_key\u001b[0;34m(self, key, axis)\u001b[0m\n\u001b[1;32m   1377\u001b[0m             \u001b[0;31m# check that the key does not exceed the maximum size of the index\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1378\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mlen_axis\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0marr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mlen_axis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1379\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mIndexError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"positional indexers are out-of-bounds\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1380\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1381\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Can only index by location with a [{self._valid_types}]\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: positional indexers are out-of-bounds"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "param = myanfis.fis_parameters(\n",
        "        n_input = 2,                # no. of Regressors\n",
        "        n_memb = 2,                 # no. of fuzzy memberships\n",
        "        batch_size = 16,            # 16 / 32 / 64 / ...\n",
        "        memb_func = 'gaussian',      # 'gaussian' / 'gbellmf' / 'sigmoid'\n",
        "        optimizer = 'sgd',          # sgd / adam / ...\n",
        "        loss = tf.keras.losses.MeanAbsoluteError(),               # mse / mae / huber_loss / mean_absolute_percentage_error / ...\n",
        "        n_epochs = 15               # 10 / 25 / 50 / 100 / ...\n",
        "        )"
      ],
      "metadata": {
        "id": "4Qn9KePqQC_8"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "75acc910",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "ac86693b-3b39-4f6f-ca51-8d97b8648575"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-8eaeba6867bf>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mtrain_index\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_index\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mkfold\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtrain_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtest_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mY_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtrain_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtest_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'X' is not defined"
          ]
        }
      ],
      "source": [
        "kfold = KFold(n_splits=2)\n",
        "histories = []\n",
        "\n",
        "\n",
        "for train_index, test_index in kfold.split(X):\n",
        "    X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
        "    Y_train, Y_test = Y.iloc[train_index], Y.iloc[test_index]\n",
        "    \n",
        "    fis = myanfis.ANFIS(n_input = param.n_input,\n",
        "                    n_memb = param.n_memb,\n",
        "                    batch_size = param.batch_size,\n",
        "                    memb_func = param.memb_func,\n",
        "                    name = 'firstAnfis' \n",
        "                    )\n",
        "\n",
        "\n",
        "    fis.model.compile(optimizer=param.optimizer,\n",
        "                      loss=param.loss,\n",
        "                      metrics=['mae']  # ['mae', 'mse']\n",
        "                      )\n",
        "\n",
        "    history = fis.fit(X_train, Y_train, epochs=param.n_epochs, batch_size=param.batch_size, validation_data=(X_test, Y_test))\n",
        "\n",
        "\n",
        "    histories.append(history)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.python.framework import errors\n",
        "\n",
        "class _NotOkStatusException(errors.OpError):\n",
        "    \"\"\"Exception raised for non-OK HTTP status codes.\"\"\"\n",
        "    pass\n",
        "\n",
        "kfold = KFold(n_splits=2)\n",
        "histories = []\n",
        "\n",
        "try:\n",
        "    for train_index, test_index in kfold.split(X):\n",
        "        X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
        "        Y_train, Y_test = Y.iloc[train_index], Y.iloc[test_index]\n",
        "\n",
        "        fis = myanfis.ANFIS(n_input=param.n_input,\n",
        "                            n_memb=param.n_memb,\n",
        "                            batch_size=param.batch_size,\n",
        "                            memb_func=param.memb_func,\n",
        "                            name='firstAnfis')\n",
        "\n",
        "        fis.model.compile(optimizer=param.optimizer,\n",
        "                          loss=param.loss,\n",
        "                          metrics=['mae'])\n",
        "\n",
        "        history = fis.fit(X_train, Y_train,\n",
        "                          epochs=param.n_epochs,\n",
        "                          batch_size=param.batch_size,\n",
        "                          validation_data=(X_test, Y_test))\n",
        "\n",
        "        histories.append(history)\n",
        "\n",
        "except _NotOkStatusException as e:\n",
        "# handle the exception here"
      ],
      "metadata": {
        "id": "yCNw25QTYeVB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 134
        },
        "outputId": "1494b6a0-f015-4d2d-85e6-fea4e37e5e48"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-21-c5f6225fd039>\"\u001b[0;36m, line \u001b[0;32m33\u001b[0m\n\u001b[0;31m    # handle the exception here\u001b[0m\n\u001b[0m                               ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fis.plotmfs()"
      ],
      "metadata": {
        "id": "aHOSq7thQ3mj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(histories[0].history).plot()"
      ],
      "metadata": {
        "id": "CW5ii_VuQ8-b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(histories[1].history).plot()"
      ],
      "metadata": {
        "id": "_NZo6BLQRAsq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from skfuzzy import gaussmf, gbellmf, sigmf\n",
        "import numpy as np\n",
        "import itertools\n",
        "import copy\n",
        "# import tensorflow as tf\n",
        "import tensorflow.compat.v1 as tf\n",
        "tf.disable_v2_behavior()\n",
        "import numpy as np, numpy\n",
        "import matplotlib.pyplot as plt\n",
        "import time"
      ],
      "metadata": {
        "id": "ioXWUue2lsi6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zQ0UuJ0mP9jY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color=\"red\"> copied MF base class from anfis module </font>"
      ],
      "metadata": {
        "id": "lHwcXrA8lXXk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### membershipfunction.py"
      ],
      "metadata": {
        "id": "sXdHSDf-mKOt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# -*- coding: utf-8 -*-\n",
        "\"\"\"\n",
        "Created on Mon Mar 31 15:41:58 2014\n",
        "\n",
        "@author: tim.meggs\n",
        "\"\"\"\n",
        "\n",
        "# from skfuzzy import gaussmf, gbellmf, sigmf\n",
        "\n",
        "class MemFuncs:\n",
        "    'Common base class for all employees'\n",
        "    funcDict = {'gaussmf': gaussmf, 'gbellmf': gbellmf, 'sigmf': sigmf}\n",
        "\n",
        "\n",
        "    def __init__(self, MFList):\n",
        "        self.MFList = MFList\n",
        "\n",
        "    def evaluateMF(self, rowInput):\n",
        "        if len(rowInput) != len(self.MFList):\n",
        "            print(\"Number of variables does not match number of rule sets\")\n",
        "\n",
        "        return [[self.funcDict[self.MFList[i][k][0]](rowInput[i],**self.MFList[i][k][1]) for k in range(len(self.MFList[i]))] for i in range(len(rowInput))]"
      ],
      "metadata": {
        "id": "Rm60GOMCleS6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### mfDerivs.py "
      ],
      "metadata": {
        "id": "fzlHVM10mT-Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# import numpy as np\n",
        "\n",
        "\n",
        "def partial_dMF(x, mf_definition, partial_parameter):\n",
        "    \"\"\"Calculates the partial derivative of a membership function at a point x.\n",
        "\n",
        "\n",
        "\n",
        "    Parameters\n",
        "    ------\n",
        "\n",
        "\n",
        "    Returns\n",
        "    ------\n",
        "\n",
        "    \"\"\"\n",
        "    mf_name = mf_definition[0]\n",
        "\n",
        "    if mf_name == 'gaussmf':\n",
        "\n",
        "        sigma = mf_definition[1]['sigma']\n",
        "        mean = mf_definition[1]['mean']\n",
        "\n",
        "        if partial_parameter == 'sigma':\n",
        "            result = (2./sigma**3) * np.exp(-(((x-mean)**2)/(sigma)**2))*(x-mean)**2\n",
        "        elif partial_parameter == 'mean':\n",
        "            result = (2./sigma**2) * np.exp(-(((x-mean)**2)/(sigma)**2))*(x-mean)\n",
        "\n",
        "    elif mf_name == 'gbellmf':\n",
        "\n",
        "        a = mf_definition[1]['a']\n",
        "        b = mf_definition[1]['b']\n",
        "        c = mf_definition[1]['c']\n",
        "\n",
        "        if partial_parameter == 'a':\n",
        "            result = (2. * b * np.power((c-x),2) * np.power(np.absolute((c-x)/a), ((2 * b) - 2))) / \\\n",
        "                (np.power(a, 3) * np.power((np.power(np.absolute((c-x)/a),(2*b)) + 1), 2))\n",
        "        elif partial_parameter == 'b':\n",
        "            result = -1 * (2 * np.power(np.absolute((c-x)/a), (2 * b)) * np.log(np.absolute((c-x)/a))) / \\\n",
        "                (np.power((np.power(np.absolute((c-x)/a), (2 * b)) + 1), 2))\n",
        "        elif partial_parameter == 'c':\n",
        "            result = (2. * b * (c-x) * np.power(np.absolute((c-x)/a), ((2 * b) - 2))) / \\\n",
        "                (np.power(a, 2) * np.power((np.power(np.absolute((c-x)/a),(2*b)) + 1), 2))\n",
        "\n",
        "    elif mf_name == 'sigmf':\n",
        "\n",
        "        b = mf_definition[1]['b']\n",
        "        c = mf_definition[1]['c']\n",
        "\n",
        "        if partial_parameter == 'b':\n",
        "            result = -1 * (c * np.exp(c * (b + x))) / \\\n",
        "                np.power((np.exp(b*c) + np.exp(c*x)), 2)\n",
        "        elif partial_parameter == 'c':\n",
        "            result = ((x - b) * np.exp(c * (x - b))) / \\\n",
        "                np.power((np.exp(c * (x - c))) + 1, 2)\n",
        "\n",
        "\n",
        "    return result"
      ],
      "metadata": {
        "id": "VOKXsIsJljyX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "# <font color=\"red\"> copied ANFIS base class from ANFIS py module -> first ANFIS class</font>\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "_LA4_r3Sk94O"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### anfis.py"
      ],
      "metadata": {
        "id": "Tj5131XOmZvs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# -*- coding: utf-8 -*-\n",
        "\"\"\"\n",
        "Created on Thu Apr 03 07:30:34 2014\n",
        "\n",
        "@author: tim.meggs\n",
        "\"\"\"\n",
        "# import itertools\n",
        "# import numpy as np\n",
        "# from membership import mfDerivs\n",
        "# import copy\n",
        "\n",
        "class ANFIS:\n",
        "    \"\"\"Class to implement an Adaptive Network Fuzzy Inference System: ANFIS\"\n",
        "\n",
        "    Attributes:\n",
        "        X\n",
        "        Y\n",
        "        XLen\n",
        "        memClass\n",
        "        memFuncs\n",
        "        memFuncsByVariable\n",
        "        rules\n",
        "        consequents\n",
        "        errors\n",
        "        memFuncsHomo\n",
        "        trainingType\n",
        "\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, X, Y, memFunction):\n",
        "        self.X = np.array(copy.copy(X))\n",
        "        self.Y = np.array(copy.copy(Y))\n",
        "        self.XLen = len(self.X)\n",
        "        self.memClass = copy.deepcopy(memFunction)\n",
        "        self.memFuncs = self.memClass.MFList\n",
        "        self.memFuncsByVariable = [[x for x in range(len(self.memFuncs[z]))] for z in range(len(self.memFuncs))]\n",
        "        self.rules = np.array(list(itertools.product(*self.memFuncsByVariable)))\n",
        "        self.consequents = np.empty(self.Y.ndim * len(self.rules) * (self.X.shape[1] + 1))\n",
        "        self.consequents.fill(0)\n",
        "        self.errors = np.empty(0)\n",
        "        self.memFuncsHomo = all(len(i)==len(self.memFuncsByVariable[0]) for i in self.memFuncsByVariable)\n",
        "        self.trainingType = 'Not trained yet'\n",
        "\n",
        "    def LSE(self, A, B, initialGamma = 1000.):\n",
        "        coeffMat = A\n",
        "        rhsMat = B\n",
        "        S = np.eye(coeffMat.shape[1])*initialGamma\n",
        "        x = np.zeros((coeffMat.shape[1],1)) # need to correct for multi-dim B\n",
        "        for i in range(len(coeffMat[:,0])):\n",
        "            a = coeffMat[i,:]\n",
        "            b = np.array(rhsMat[i])\n",
        "            S = S - (np.array(np.dot(np.dot(np.dot(S,np.matrix(a).transpose()),np.matrix(a)),S)))/(1+(np.dot(np.dot(S,a),a)))\n",
        "            x = x + (np.dot(S,np.dot(np.matrix(a).transpose(),(np.matrix(b)-np.dot(np.matrix(a),x)))))\n",
        "        return x\n",
        "\n",
        "    def trainHybridJangOffLine(self, epochs=5, tolerance=1e-5, initialGamma=1000, k=0.01):\n",
        "\n",
        "        self.trainingType = 'trainHybridJangOffLine'\n",
        "        convergence = False\n",
        "        epoch = 1\n",
        "\n",
        "        while (epoch < epochs) and (convergence is not True):\n",
        "\n",
        "            #layer four: forward pass\n",
        "            [layerFour, wSum, w] = forwardHalfPass(self, self.X)\n",
        "\n",
        "            #layer five: least squares estimate\n",
        "            layerFive = np.array(self.LSE(layerFour,self.Y,initialGamma))\n",
        "            self.consequents = layerFive\n",
        "            layerFive = np.dot(layerFour,layerFive)\n",
        "\n",
        "            #error\n",
        "            error = np.sum((self.Y-layerFive.T)**2)\n",
        "            print('current error: '+ str(error))\n",
        "            average_error = np.average(np.absolute(self.Y-layerFive.T))\n",
        "            self.errors = np.append(self.errors,error)\n",
        "\n",
        "            if len(self.errors) != 0:\n",
        "                if self.errors[len(self.errors)-1] < tolerance:\n",
        "                    convergence = True\n",
        "\n",
        "            # back propagation\n",
        "            if convergence is not True:\n",
        "                cols = range(len(self.X[0,:]))\n",
        "                dE_dAlpha = list(backprop(self, colX, cols, wSum, w, layerFive) for colX in range(self.X.shape[1]))\n",
        "\n",
        "\n",
        "            if len(self.errors) >= 4:\n",
        "                if (self.errors[-4] > self.errors[-3] > self.errors[-2] > self.errors[-1]):\n",
        "                    k = k * 1.1\n",
        "\n",
        "            if len(self.errors) >= 5:\n",
        "                if (self.errors[-1] < self.errors[-2]) and (self.errors[-3] < self.errors[-2]) and (self.errors[-3] < self.errors[-4]) and (self.errors[-5] > self.errors[-4]):\n",
        "                    k = k * 0.9\n",
        "\n",
        "            ## handling of variables with a different number of MFs\n",
        "            t = []\n",
        "            for x in range(len(dE_dAlpha)):\n",
        "                for y in range(len(dE_dAlpha[x])):\n",
        "                    for z in range(len(dE_dAlpha[x][y])):\n",
        "                        t.append(dE_dAlpha[x][y][z])\n",
        "\n",
        "            eta = k / np.abs(np.sum(t))\n",
        "\n",
        "            if(np.isinf(eta)):\n",
        "                eta = k\n",
        "\n",
        "            ## handling of variables with a different number of MFs\n",
        "            dAlpha = copy.deepcopy(dE_dAlpha)\n",
        "            if not(self.memFuncsHomo):\n",
        "                for x in range(len(dE_dAlpha)):\n",
        "                    for y in range(len(dE_dAlpha[x])):\n",
        "                        for z in range(len(dE_dAlpha[x][y])):\n",
        "                            dAlpha[x][y][z] = -eta * dE_dAlpha[x][y][z]\n",
        "            else:\n",
        "                dAlpha = -eta * np.array(dE_dAlpha)\n",
        "\n",
        "\n",
        "            for varsWithMemFuncs in range(len(self.memFuncs)):\n",
        "                for MFs in range(len(self.memFuncsByVariable[varsWithMemFuncs])):\n",
        "                    paramList = sorted(self.memFuncs[varsWithMemFuncs][MFs][1])\n",
        "                    for param in range(len(paramList)):\n",
        "                        self.memFuncs[varsWithMemFuncs][MFs][1][paramList[param]] = self.memFuncs[varsWithMemFuncs][MFs][1][paramList[param]] + dAlpha[varsWithMemFuncs][MFs][param]\n",
        "            epoch = epoch + 1\n",
        "\n",
        "\n",
        "        self.fittedValues = predict(self,self.X)\n",
        "        self.residuals = self.Y - self.fittedValues[:,0]\n",
        "\n",
        "        return self.fittedValues\n",
        "\n",
        "\n",
        "    def plotErrors(self):\n",
        "        if self.trainingType == 'Not trained yet':\n",
        "            print(self.trainingType)\n",
        "        else:\n",
        "            import matplotlib.pyplot as plt\n",
        "            plt.plot(range(len(self.errors)),self.errors,'ro', label='errors')\n",
        "            plt.ylabel('error')\n",
        "            plt.xlabel('epoch')\n",
        "            plt.show()\n",
        "\n",
        "    def plotMF(self, x, inputVar):\n",
        "        import matplotlib.pyplot as plt\n",
        "        from skfuzzy import gaussmf, gbellmf, sigmf\n",
        "\n",
        "        for mf in range(len(self.memFuncs[inputVar])):\n",
        "            if self.memFuncs[inputVar][mf][0] == 'gaussmf':\n",
        "                y = gaussmf(x,**self.memClass.MFList[inputVar][mf][1])\n",
        "            elif self.memFuncs[inputVar][mf][0] == 'gbellmf':\n",
        "                y = gbellmf(x,**self.memClass.MFList[inputVar][mf][1])\n",
        "            elif self.memFuncs[inputVar][mf][0] == 'sigmf':\n",
        "                y = sigmf(x,**self.memClass.MFList[inputVar][mf][1])\n",
        "\n",
        "            plt.plot(x,y,'r')\n",
        "\n",
        "        plt.show()\n",
        "\n",
        "    def plotResults(self):\n",
        "        if self.trainingType == 'Not trained yet':\n",
        "            print(self.trainingType)\n",
        "        else:\n",
        "            import matplotlib.pyplot as plt\n",
        "            plt.plot(range(len(self.fittedValues)),self.fittedValues,'r', label='trained')\n",
        "            plt.plot(range(len(self.Y)),self.Y,'b', label='original')\n",
        "            plt.legend(loc='upper left')\n",
        "            plt.show()\n",
        "\n",
        "\n",
        "\n",
        "def forwardHalfPass(ANFISObj, Xs):\n",
        "    layerFour = np.empty(0,)\n",
        "    wSum = []\n",
        "\n",
        "    for pattern in range(len(Xs[:,0])):\n",
        "        #layer one\n",
        "        layerOne = ANFISObj.memClass.evaluateMF(Xs[pattern,:])\n",
        "\n",
        "        #layer two\n",
        "        miAlloc = [[layerOne[x][ANFISObj.rules[row][x]] for x in range(len(ANFISObj.rules[0]))] for row in range(len(ANFISObj.rules))]\n",
        "        layerTwo = np.array([np.product(x) for x in miAlloc]).T\n",
        "        if pattern == 0:\n",
        "            w = layerTwo\n",
        "        else:\n",
        "            w = np.vstack((w,layerTwo))\n",
        "\n",
        "        #layer three\n",
        "        wSum.append(np.sum(layerTwo))\n",
        "        if pattern == 0:\n",
        "            wNormalized = layerTwo/wSum[pattern]\n",
        "        else:\n",
        "            wNormalized = np.vstack((wNormalized,layerTwo/wSum[pattern]))\n",
        "\n",
        "        #prep for layer four (bit of a hack)\n",
        "        layerThree = layerTwo/wSum[pattern]\n",
        "        rowHolder = np.concatenate([x*np.append(Xs[pattern,:],1) for x in layerThree])\n",
        "        layerFour = np.append(layerFour,rowHolder)\n",
        "\n",
        "    w = w.T\n",
        "    wNormalized = wNormalized.T\n",
        "\n",
        "    layerFour = np.array(np.array_split(layerFour,pattern + 1))\n",
        "\n",
        "    return layerFour, wSum, w\n",
        "\n",
        "\n",
        "def backprop(ANFISObj, columnX, columns, theWSum, theW, theLayerFive):\n",
        "\n",
        "    paramGrp = [0]* len(ANFISObj.memFuncs[columnX])\n",
        "    for MF in range(len(ANFISObj.memFuncs[columnX])):\n",
        "\n",
        "        parameters = np.empty(len(ANFISObj.memFuncs[columnX][MF][1]))\n",
        "        timesThru = 0\n",
        "        for alpha in sorted(ANFISObj.memFuncs[columnX][MF][1].keys()):\n",
        "\n",
        "            bucket3 = np.empty(len(ANFISObj.X))\n",
        "            for rowX in range(len(ANFISObj.X)):\n",
        "                varToTest = ANFISObj.X[rowX,columnX]\n",
        "                tmpRow = np.empty(len(ANFISObj.memFuncs))\n",
        "                tmpRow.fill(varToTest)\n",
        "\n",
        "                bucket2 = np.empty(ANFISObj.Y.ndim)\n",
        "                for colY in range(ANFISObj.Y.ndim):\n",
        "\n",
        "                    rulesWithAlpha = np.array(np.where(ANFISObj.rules[:,columnX]==MF))[0]\n",
        "                    adjCols = np.delete(columns,columnX)\n",
        "\n",
        "                    senSit = partial_dMF(ANFISObj.X[rowX,columnX],ANFISObj.memFuncs[columnX][MF],alpha)\n",
        "                    # produces d_ruleOutput/d_parameterWithinMF\n",
        "                    dW_dAplha = senSit * np.array([np.prod([ANFISObj.memClass.evaluateMF(tmpRow)[c][ANFISObj.rules[r][c]] for c in adjCols]) for r in rulesWithAlpha])\n",
        "\n",
        "                    bucket1 = np.empty(len(ANFISObj.rules[:,0]))\n",
        "                    for consequent in range(len(ANFISObj.rules[:,0])):\n",
        "                        fConsequent = np.dot(np.append(ANFISObj.X[rowX,:],1.),ANFISObj.consequents[((ANFISObj.X.shape[1] + 1) * consequent):(((ANFISObj.X.shape[1] + 1) * consequent) + (ANFISObj.X.shape[1] + 1)),colY])\n",
        "                        acum = 0\n",
        "                        if consequent in rulesWithAlpha:\n",
        "                            acum = dW_dAplha[np.where(rulesWithAlpha==consequent)] * theWSum[rowX]\n",
        "\n",
        "                        acum = acum - theW[consequent,rowX] * np.sum(dW_dAplha)\n",
        "                        acum = acum / theWSum[rowX]**2\n",
        "                        bucket1[consequent] = fConsequent * acum\n",
        "\n",
        "                    sum1 = np.sum(bucket1)\n",
        "\n",
        "                    if ANFISObj.Y.ndim == 1:\n",
        "                        bucket2[colY] = sum1 * (ANFISObj.Y[rowX]-theLayerFive[rowX,colY])*(-2)\n",
        "                    else:\n",
        "                        bucket2[colY] = sum1 * (ANFISObj.Y[rowX,colY]-theLayerFive[rowX,colY])*(-2)\n",
        "\n",
        "                sum2 = np.sum(bucket2)\n",
        "                bucket3[rowX] = sum2\n",
        "\n",
        "            sum3 = np.sum(bucket3)\n",
        "            parameters[timesThru] = sum3\n",
        "            timesThru = timesThru + 1\n",
        "\n",
        "        paramGrp[MF] = parameters\n",
        "\n",
        "    return paramGrp\n",
        "\n",
        "\n",
        "def predict(ANFISObj, varsToTest):\n",
        "\n",
        "    [layerFour, wSum, w] = forwardHalfPass(ANFISObj, varsToTest)\n",
        "\n",
        "    #layer five\n",
        "    layerFive = np.dot(layerFour,ANFISObj.consequents)\n",
        "\n",
        "    return layerFive\n",
        "\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    print(\"I am main!\")"
      ],
      "metadata": {
        "id": "xrxTSembkmsM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color='blue'> Second anfis class -> (_ANFIS) </font>"
      ],
      "metadata": {
        "id": "LVEP9St5oudy"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7EiHaK2VTrJW"
      },
      "outputs": [],
      "source": [
        "# import tensorflow as tf\n",
        "# import numpy as np\n",
        "# import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "class _ANFIS:\n",
        "\n",
        "    def __init__(self, n_inputs, n_rules, learning_rate=1e-2):\n",
        "        self.n = n_inputs\n",
        "        self.m = n_rules\n",
        "        self.inputs = tf.placeholder(tf.float32, shape=(None, n_inputs))  # Input\n",
        "        self.targets = tf.placeholder(tf.float32, shape=None)  # Desired output\n",
        "        mu = tf.get_variable(\"mu\", [n_rules * n_inputs],\n",
        "                             initializer=tf.random_normal_initializer(0, 1))  # Means of Gaussian MFS\n",
        "        sigma = tf.get_variable(\"sigma\", [n_rules * n_inputs],\n",
        "                                initializer=tf.random_normal_initializer(0, 1))  # Standard deviations of Gaussian MFS\n",
        "        y = tf.get_variable(\"y\", [1, n_rules], initializer=tf.random_normal_initializer(0, 1))  # Sequent centers\n",
        "\n",
        "        self.params = tf.trainable_variables()\n",
        "\n",
        "        self.rul = tf.reduce_prod(\n",
        "            tf.reshape(tf.exp(-0.5 * tf.square(tf.subtract(tf.tile(self.inputs, (1, n_rules)), mu)) / tf.square(sigma)),\n",
        "                       (-1, n_rules, n_inputs)), axis=2)  # Rule activations\n",
        "        # Fuzzy base expansion function:\n",
        "        num = tf.reduce_sum(tf.multiply(self.rul, y), axis=1)\n",
        "        den = tf.clip_by_value(tf.reduce_sum(self.rul, axis=1), 1e-12, 1e12)\n",
        "        self.out = tf.divide(num, den)\n",
        "\n",
        "        self.loss = tf.losses.huber_loss(self.targets, self.out)  # Loss function computation\n",
        "        # Other loss functions for regression, uncomment to try them:\n",
        "        # loss = tf.sqrt(tf.losses.mean_squared_error(target, out))\n",
        "        # loss = tf.losses.absolute_difference(target, out)\n",
        "        self.optimize = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(self.loss)  # Optimization step\n",
        "        # Other optimizers, uncomment to try them:\n",
        "        # self.optimize = tf.train.RMSPropOptimizer(learning_rate=learning_rate).minimize(self.loss)\n",
        "        # self.optimize = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(self.loss)\n",
        "        self.init_variables = tf.global_variables_initializer()  # Variable initializer\n",
        "\n",
        "    def infer(self, sess, x, targets=None):\n",
        "        if targets is None:\n",
        "            return sess.run(self.out, feed_dict={self.inputs: x})\n",
        "        else:\n",
        "            return sess.run([self.out, self.loss], feed_dict={self.inputs: x, self.targets: targets})\n",
        "\n",
        "    def train(self, sess, x, targets):\n",
        "        yp, l, _ = sess.run([self.out, self.loss, self.optimize], feed_dict={self.inputs: x, self.targets: targets})\n",
        "        return l, yp\n",
        "\n",
        "    def plotmfs(self, sess):\n",
        "        mus = sess.run(self.params[0])\n",
        "        mus = np.reshape(mus, (self.m, self.n))\n",
        "        sigmas = sess.run(self.params[1])\n",
        "        sigmas = np.reshape(sigmas, (self.m, self.n))\n",
        "        y = sess.run(self.params[2])\n",
        "        xn = np.linspace(-1.5, 1.5, 1000)\n",
        "        for r in range(self.m):\n",
        "            if r % 4 == 0:\n",
        "                plt.figure(figsize=(11, 6), dpi=80)\n",
        "            plt.subplot(2, 2, (r % 4) + 1)\n",
        "            ax = plt.subplot(2, 2, (r % 4) + 1)\n",
        "            ax.set_title(\"Rule %d, sequent center: %f\" % ((r + 1), y[0, r]))\n",
        "            for i in range(self.n):\n",
        "                plt.plot(xn, np.exp(-0.5 * ((xn - mus[r, i]) ** 2) / (sigmas[r, i] ** 2)))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color='orange'> Second _ANFIS class, test result </font>\n",
        "\n"
      ],
      "metadata": {
        "id": "GSnmfmVG3Wce"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zxJRdXz4RciU"
      },
      "outputs": [],
      "source": [
        "# import time\n",
        "# import tensorflow as tf\n",
        "# import numpy as np\n",
        "# import matplotlib.pyplot as plt\n",
        "# from anfis import ANFIS\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# Mackey-Glass series computation\n",
        "def mackey(n_iters):\n",
        "    x = np.zeros((n_iters,))\n",
        "    x[0:30] = 0.23 * np.ones((30,))\n",
        "    t_s = 30\n",
        "    for i in range(30, n_iters - 1):\n",
        "        a = x[i]\n",
        "        b = x[i - t_s]\n",
        "        y = ((0.2 * b) / (1 + b ** 10)) + 0.9 * a\n",
        "        x[i + 1] = y\n",
        "    return x\n",
        "\n",
        "\n",
        "# Generate dataset\n",
        "D = 4  # number of regressors\n",
        "T = 1  # delay\n",
        "N = 2000  # Number of points to generate\n",
        "mg_series = mackey(N)[499:]  # Use last 1500 points\n",
        "data = np.zeros((N - 500 - T - (D - 1) * T, D))\n",
        "lbls = np.zeros((N - 500 - T - (D - 1) * T,))\n",
        "\n",
        "for t in range((D - 1) * T, N - 500 - T):\n",
        "    data[t - (D - 1) * T, :] = [mg_series[t - 3 * T], mg_series[t - 2 * T], mg_series[t - T], mg_series[t]]\n",
        "    lbls[t - (D - 1) * T] = mg_series[t + T]\n",
        "trnData = data[:lbls.size - round(lbls.size * 0.3), :]\n",
        "trnLbls = lbls[:lbls.size - round(lbls.size * 0.3)]\n",
        "chkData = data[lbls.size - round(lbls.size * 0.3):, :]\n",
        "chkLbls = lbls[lbls.size - round(lbls.size * 0.3):]\n",
        "\n",
        "# ANFIS params and Tensorflow graph initialization\n",
        "m = 16  # number of rules\n",
        "alpha = 0.01  # learning rate\n",
        "\n",
        "fis = _ANFIS(n_inputs=D, n_rules=m, learning_rate=alpha)\n",
        "\n",
        "# Training\n",
        "num_epochs = 100\n",
        "\n",
        "# Initialize session to make computations on the Tensorflow graph\n",
        "with tf.Session() as sess:\n",
        "    # Initialize model parameters\n",
        "    sess.run(fis.init_variables)\n",
        "    trn_costs = []\n",
        "    val_costs = []\n",
        "    time_start = time.time()\n",
        "    for epoch in range(num_epochs):\n",
        "        #  Run an update step\n",
        "        trn_loss, trn_pred = fis.train(sess, trnData, trnLbls)\n",
        "        # Evaluate on validation set\n",
        "        val_pred, val_loss = fis.infer(sess, chkData, chkLbls)\n",
        "        if epoch % 10 == 0:\n",
        "            print(\"Train cost after epoch %i: %f\" % (epoch, trn_loss))\n",
        "        if epoch == num_epochs - 1:\n",
        "            time_end = time.time()\n",
        "            print(\"Elapsed time: %f\" % (time_end - time_start))\n",
        "            print(\"Validation loss: %f\" % val_loss)\n",
        "            # Plot real vs. predicted\n",
        "            pred = np.vstack((np.expand_dims(trn_pred, 1), np.expand_dims(val_pred, 1)))\n",
        "            plt.figure(1)\n",
        "            plt.plot(mg_series)\n",
        "            plt.plot(pred)\n",
        "        trn_costs.append(trn_loss)\n",
        "        val_costs.append(val_loss)\n",
        "    # Plot the cost over epochs\n",
        "    plt.figure(2)\n",
        "    plt.subplot(2, 1, 1)\n",
        "    plt.plot(np.squeeze(trn_costs))\n",
        "    plt.title(\"Training loss, Learning rate =\" + str(alpha))\n",
        "    plt.subplot(2, 1, 2)\n",
        "    plt.plot(np.squeeze(val_costs))\n",
        "    plt.title(\"Validation loss, Learning rate =\" + str(alpha))\n",
        "    plt.ylabel('Cost')\n",
        "    plt.xlabel('Epochs')\n",
        "    # Plot resulting membership functions\n",
        "    fis.plotmfs(sess)\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# <font color='orange'>first ANFIS class - test code, (trainingSet.txt and test code copied from github) </font>"
      ],
      "metadata": {
        "id": "OoGdZcDH2jC8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HxNGz6yzuOJC"
      },
      "outputs": [],
      "source": [
        "# import anfis\n",
        "# import membership.mfDerivs\n",
        "# import membership.membershipfunction\n",
        "# import numpy\n",
        "\n",
        "\n",
        "\n",
        "ts = numpy.loadtxt(\"trainingSet.txt\", usecols=[1,2,3])\n",
        "X = ts[:,0:2]\n",
        "Y = ts[:,2]\n",
        "\n",
        "mf = [[['gaussmf',{'mean':0.,'sigma':1.}],['gaussmf',{'mean':-1.,'sigma':2.}],['gaussmf',{'mean':-4.,'sigma':10.}],['gaussmf',{'mean':-7.,'sigma':7.}]],\n",
        "            [['gaussmf',{'mean':1.,'sigma':2.}],['gaussmf',{'mean':2.,'sigma':3.}],['gaussmf',{'mean':-2.,'sigma':10.}],['gaussmf',{'mean':-10.5,'sigma':5.}]]]\n",
        "\n",
        "\n",
        "mfc = MemFuncs(mf)\n",
        "anf = ANFIS(X, Y, mfc)\n",
        "anf.trainHybridJangOffLine(epochs=20)\n",
        "print(round(anf.consequents[-1][0],6))\n",
        "print(round(anf.consequents[-2][0],6))\n",
        "print(round(anf.fittedValues[9][0],6))\n",
        "if round(anf.consequents[-1][0],6) == -5.275538 and round(anf.consequents[-2][0],6) == -1.990703 and round(anf.fittedValues[9][0],6) == 0.002249:\n",
        "\tprint('test is good')\n",
        "\n",
        "print(\"Plotting errors\")\n",
        "anf.plotErrors()\n",
        "print(\"Plotting results\")\n",
        "anf.plotResults()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}