Fuzzy_Discernibility_Matrix.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>L</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1.1</td>\n",
       "      <td>2.5</td>\n",
       "      <td>R</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>R</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.3</td>\n",
       "      <td>2.7</td>\n",
       "      <td>2.5</td>\n",
       "      <td>L</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A    B    C  D\n",
       "0  1.2  2.3  2.5  L\n",
       "1  1.4  1.1  2.5  R\n",
       "2  2.5  3.0  2.5  R\n",
       "3  3.3  2.7  2.5  L"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd \n",
    "  \n",
    "# intialise data of lists. \n",
    "data = {'A':[1.2,1.4,2.5,3.3], \n",
    "        'B':[2.3,1.1,3.0,2.7],\n",
    "        'C':[2.5,2.5,2.5,2.5],\n",
    "        'D':['L','R','R','L']} \n",
    "  \n",
    "# Create DataFrame \n",
    "df = pd.DataFrame(data) \n",
    "dft = df.copy()  \n",
    "# Print the output. \n",
    "df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['L', 'R']\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<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>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1.1</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.3</td>\n",
       "      <td>2.7</td>\n",
       "      <td>2.5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A    B    C  D\n",
       "0  1.2  2.3  2.5  0\n",
       "1  1.4  1.1  2.5  1\n",
       "2  2.5  3.0  2.5  1\n",
       "3  3.3  2.7  2.5  0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "\n",
    "# creating instance of labelencoder\n",
    "labelencoder = preprocessing.LabelEncoder()\n",
    "labelencoder.fit(df['D'])\n",
    "print(list(labelencoder.classes_))\n",
    "\n",
    "# Assigning numerical values and storing in another column\n",
    "df['D'] = labelencoder.fit_transform(df['D'])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "### skfuzzy.membership.gaussmf \n",
    "\n",
    "def gaussmf(x, mean, sigma):\n",
    "    \"\"\"\n",
    "    Gaussian fuzzy membership function.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    x : 1d array or iterable\n",
    "        Independent variable.\n",
    "    mean : float\n",
    "        Gaussian parameter for center (mean) value.\n",
    "    sigma : float\n",
    "        Gaussian parameter for standard deviation.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    y : 1d array\n",
    "        Gaussian membership function for x\n",
    "\n",
    "    \"\"\"\n",
    "    eps=1e-16\n",
    "    \n",
    "    return np.exp(-((x - mean) ** 2.) / (float(sigma) ** 2.+eps))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets = {}\n",
    "by_class = df.groupby('D')\n",
    "\n",
    "for groups, data in by_class:\n",
    "    datasets[groups] = data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0:      A    B    C  D\n",
       " 0  1.2  2.3  2.5  0\n",
       " 3  3.3  2.7  2.5  0,\n",
       " 1:      A    B    C  D\n",
       " 1  1.4  1.1  2.5  1\n",
       " 2  2.5  3.0  2.5  1}"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     A    B    C  D\n",
      "0  1.2  2.3  2.5  0\n",
      "3  3.3  2.7  2.5  0\n",
      "mean [[2.25, 2.5, 2.5, 0.0]]\n",
      "std [[1.4849242404917498, 0.2828427124746193, 0.0, 0.0]]\n",
      "     A    B    C  D\n",
      "1  1.4  1.1  2.5  1\n",
      "2  2.5  3.0  2.5  1\n",
      "mean [[2.25, 2.5, 2.5, 0.0], [1.95, 2.05, 2.5, 1.0]]\n",
      "std [[1.4849242404917498, 0.2828427124746193, 0.0, 0.0], [0.7778174593052023, 1.34350288425444, 0.0, 0.0]]\n"
     ]
    }
   ],
   "source": [
    "len(datasets)\n",
    "meand=[]\n",
    "stdd=[]\n",
    "for i in range(len(datasets)):\n",
    "    print(datasets[i])\n",
    "    meand.append(list(datasets[i].mean(axis = 0)))\n",
    "    print('mean',meand)\n",
    "    stdd.append(list(datasets[i].std(axis = 0)))\n",
    "    print('std',stdd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6273488082851381"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eps=1e-16\n",
    "f=np.exp(-((2.3 - 2.5) ** 2.) / (float(0.2929) ** 2.+eps))\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     0    1    2  3\n",
      "0  1.2  2.3  2.5  0\n",
      "3  3.3  2.7  2.5  0\n",
      "     0    1    2  3\n",
      "1  1.4  1.1  2.5  1\n",
      "2  2.5  3.0  2.5  1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[6.06530660e-01, 3.94651546e-01, 6.06530660e-01, 9.65966583e-01,\n",
       "        1.00000000e+00, 1.00000000e+00],\n",
       "       [7.20604815e-01, 6.06530660e-01, 2.28973485e-11, 6.06530660e-01,\n",
       "        1.00000000e+00, 1.00000000e+00],\n",
       "       [9.72053270e-01, 6.06530660e-01, 4.39369336e-02, 6.06530660e-01,\n",
       "        1.00000000e+00, 1.00000000e+00],\n",
       "       [6.06530660e-01, 4.91736831e-02, 6.06530660e-01, 7.91304822e-01,\n",
       "        1.00000000e+00, 1.00000000e+00]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "X=df.to_numpy()\n",
    "r,c=X.shape\n",
    "\n",
    "oldf=df.columns\n",
    "newf=list(range(c))\n",
    "df.rename(columns=dict(zip(oldf, newf)), inplace=True) #renaming column\n",
    "D=list(df[newf[-1]])\n",
    "\n",
    "labelencoder.fit(df[newf[-1]])\n",
    "list(labelencoder.classes_)\n",
    "classes=len(list(labelencoder.classes_))\n",
    "FD=np.zeros((r,(c-1)*classes))\n",
    "\n",
    "for i in range(len(datasets)):\n",
    "    oldf=datasets[i].columns\n",
    "    newf=list(range(c))\n",
    "    datasets[i].rename(columns=dict(zip(oldf, newf)), inplace=True) #renaming column\n",
    "    print(datasets[i])\n",
    "\n",
    "for j in range(c-1):\n",
    "    for i in range(r):\n",
    "        l=((j+1)*classes)-1\n",
    "        for k in range(classes):\n",
    "            g=gaussmf(X[i][j], np.array(meand[k][j]), np.array(stdd[k][j]))\n",
    "            #print(g)\n",
    "            FD[i][l-1]=g #float(str(round(g, 8)))\n",
    "            l = l+1\n",
    "            \n",
    "FD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 0]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D=list(df[newf[-1]])\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D=np.array(D)\n",
    "D.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=D.reshape(4,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6.06530660e-01, 3.94651546e-01, 6.06530660e-01, 9.65966583e-01,\n",
       "        1.00000000e+00, 1.00000000e+00, 0.00000000e+00],\n",
       "       [7.20604815e-01, 6.06530660e-01, 2.28973485e-11, 6.06530660e-01,\n",
       "        1.00000000e+00, 1.00000000e+00, 1.00000000e+00],\n",
       "       [9.72053270e-01, 6.06530660e-01, 4.39369336e-02, 6.06530660e-01,\n",
       "        1.00000000e+00, 1.00000000e+00, 1.00000000e+00],\n",
       "       [6.06530660e-01, 4.91736831e-02, 6.06530660e-01, 7.91304822e-01,\n",
       "        1.00000000e+00, 1.00000000e+00, 0.00000000e+00]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F=np.concatenate((FD, D), axis=1)\n",
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.606531</td>\n",
       "      <td>0.394652</td>\n",
       "      <td>6.065307e-01</td>\n",
       "      <td>0.965967</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.720605</td>\n",
       "      <td>0.606531</td>\n",
       "      <td>2.289735e-11</td>\n",
       "      <td>0.606531</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.972053</td>\n",
       "      <td>0.606531</td>\n",
       "      <td>4.393693e-02</td>\n",
       "      <td>0.606531</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.606531</td>\n",
       "      <td>0.049174</td>\n",
       "      <td>6.065307e-01</td>\n",
       "      <td>0.791305</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1             2         3    4    5    6\n",
       "0  0.606531  0.394652  6.065307e-01  0.965967  1.0  1.0  0.0\n",
       "1  0.720605  0.606531  2.289735e-11  0.606531  1.0  1.0  1.0\n",
       "2  0.972053  0.606531  4.393693e-02  0.606531  1.0  1.0  1.0\n",
       "3  0.606531  0.049174  6.065307e-01  0.791305  1.0  1.0  0.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create Fuzzyfied DataFrame \n",
    "fdf = pd.DataFrame(F) \n",
    "  \n",
    "# Print the output. \n",
    "fdf "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fuzzy_distance10(x,y):\n",
    "    eps = 1e-16\n",
    "    d = 1-(sum(min(x,y))/(sum(min(x,y))+eps))\n",
    "    \n",
    "    return d\n",
    "\n",
    "def getthefuzzyvalues(F,p,t,cls):\n",
    "    \n",
    "    temp=[]\n",
    "    for i in range(cls):\n",
    "        temp.append(F[p][((t)*cls)+i])\n",
    "        \n",
    "    return temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Valid entries in Discernibilty Matrix:  [[0.0, 2.220446049250313e-16, 0.0], [0.0, 2.220446049250313e-16, 0.0], [2.220446049250313e-16, 2.220446049250313e-16, 0.0], [2.220446049250313e-16, 2.220446049250313e-16, 0.0]]\n"
     ]
    }
   ],
   "source": [
    "S=[]\n",
    "for i in range(r):\n",
    "    for j in range(r):\n",
    "        if i>j and F[i][-1]!=F[j][-1]:\n",
    "            dv=[]\n",
    "            for k in range(c-1):\n",
    "                x=getthefuzzyvalues(F,i,k,classes)\n",
    "                y=getthefuzzyvalues(F,j,k,classes)\n",
    "                dist=fuzzy_distance10(x,y)\n",
    "                #dist=float(str(round(dist, 4)))\n",
    "             \n",
    "                dv.append(dist)\n",
    "        \n",
    "            S.append(dv)\n",
    "\n",
    "print('\\nValid entries in Discernibilty Matrix: ',S)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.11022302e-16, 2.22044605e-16, 0.00000000e+00])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=np.mean(S,axis=0)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 1], dtype=int64)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0], dtype=int64)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ids = A.argsort()[::-1][:2]\n",
    "ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0], dtype=int64)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best=2\n",
    "ids=np.flip(np.argsort(A))\n",
    "reduct=ids[:best]\n",
    "reduct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>1</th>\n",
       "      <th>0</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2.3</td>\n",
       "      <td>1.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.1</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>2.7</td>\n",
       "      <td>3.3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     1    0  3\n",
       "0  2.3  1.2  0\n",
       "1  1.1  1.4  1\n",
       "2  3.0  2.5  1\n",
       "3  2.7  3.3  0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx=list(reduct)\n",
    "idx.append(newf[-1])\n",
    "df[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Before Reduct Computation: \n",
      "      A    B    C  D\n",
      "0  1.2  2.3  2.5  L\n",
      "1  1.4  1.1  2.5  R\n",
      "2  2.5  2.0  2.5  R\n",
      "3  3.3  2.7  2.5  L\n",
      "\n",
      "After changing the column names to 0 to ...\n",
      "      0    1    2  3\n",
      "0  1.2  2.3  2.5  L\n",
      "1  1.4  1.1  2.5  R\n",
      "2  2.5  2.0  2.5  R\n",
      "3  3.3  2.7  2.5  L\n",
      "\n",
      "After Reduct Computation: \n",
      "      1    0  3\n",
      "0  2.3  1.2  L\n",
      "1  1.1  1.4  R\n",
      "2  2.0  2.5  R\n",
      "3  2.7  3.3  L\n",
      "\n",
      "Obtained Reduct: 2-best discriminating features [1 0]\n",
      "\n",
      "Total execution time for FDM: 0.005956 seconds\n"
     ]
    }
   ],
   "source": [
    "#### Calling My Fuuzy Discernibility Matrix-based k-best discriminating features selection Algorithm ###\n",
    "\n",
    "import pandas as pd \n",
    "import time\n",
    "import my_fuzzy_discrn_mat\n",
    "\n",
    "######### Entry Main ##########    \n",
    "# intialise data of lists. \n",
    "data = {'A':[1.2,1.4,2.5,3.3], \n",
    "        'B':[2.3,1.1,2.0,2.7],\n",
    "        'C':[2.5,2.5,2.5,2.5],\n",
    "        'D':['L','R','R','L']} \n",
    "  \n",
    "# Create DataFrame \n",
    "df = pd.DataFrame(data) \n",
    "best=2\n",
    "\n",
    "# Print the output. \n",
    "print('\\nBefore Reduct Computation: \\n',df) \n",
    "t1=time.time()\n",
    "rdf, rf = my_fuzzy_discrn_mat.my_fuzzy_discrn_mat(df,best) \n",
    "t2=time.time()-t1\n",
    "print('\\nAfter Reduct Computation: \\n',rdf) \n",
    "print('\\nObtained Reduct: {}-best discriminating features {}'.format(best,rf))\n",
    "print('\\nTotal execution time for FDM: {:.6f} seconds'.format(t2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}