Discernibility_Matrix.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 248,
   "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": 248,
     "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",
    "  \n",
    "# Print the output. \n",
    "df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "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": 249,
     "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": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\programdata\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_discretization.py:159: UserWarning: Feature 2 is constant and will be replaced with 0.\n",
      "  \"replaced with 0.\" % jj)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import KBinsDiscretizer\n",
    "\n",
    "X=df.to_numpy()\n",
    "# transform the dataset with KBinsDiscretizer\n",
    "enc = KBinsDiscretizer(n_bins=3, encode='ordinal',strategy='uniform')\n",
    "X_binned = enc.fit_transform(X.tolist())\n",
    "X_binned=X_binned+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 1., 1.],\n",
       "       [1., 1., 1., 3.],\n",
       "       [2., 3., 1., 3.],\n",
       "       [3., 3., 1., 1.]])"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_binned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-1:B\n",
      "3-1:A\n",
      "3-1:A B\n",
      "4-2:A\n",
      "4-2:A B\n",
      "4-3:A\n"
     ]
    }
   ],
   "source": [
    "r,c = X_binned.shape\n",
    "f = ['A','B','C']\n",
    "D = []\n",
    "  \n",
    "# Create DataFrame \n",
    "for i in range(r):\n",
    "    for j in range(r):\n",
    "        if i>j and X_binned[i][-1]!=X_binned[j][-1]:\n",
    "            str1=''\n",
    "            temp=[]\n",
    "            fg=0\n",
    "            for k in range(c-1):\n",
    "                if X_binned[i][k]!=X_binned[j][k]:\n",
    "                    if k==0 or str1==\"\":\n",
    "                        str1 = str1+f[k]\n",
    "                        print('{}-{}:{}'.format(i+1,j+1,str1))\n",
    "                    else:\n",
    "                        str1 = str1+\" \"+f[k]\n",
    "                        print('{}-{}:{}'.format(i+1,j+1,str1))\n",
    "             \n",
    "            D.append(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'A B', 'A B', 'A']"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=len(D)\n",
    "core =[]\n",
    "for i in range(l):\n",
    "    if len(D[i])==1:\n",
    "        core.append(D[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'A']"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=len(core)\n",
    "reduct=[]\n",
    "for i in range(l):\n",
    "    c=0\n",
    "    for j in range(t):\n",
    "        if D[i].find(core[j]) != -1 and len(D[i])>1:\n",
    "            c=c+1\n",
    "            \n",
    "    if c==t:\n",
    "        reduct=D[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A B'"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "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>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>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1.1</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>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.3</td>\n",
       "      <td>2.7</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A    B  D\n",
       "0  1.2  2.3  0\n",
       "1  1.4  1.1  1\n",
       "2  2.5  3.0  1\n",
       "3  3.3  2.7  0"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create reduced DataFrame \n",
    "dfr=df[[\"A\",\"B\",\"D\"]] \n",
    "\n",
    "# Print reduced DataFrame\n",
    "dfr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'D']"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf=reduct.split(\" \")\n",
    "rf.append(\"D\")\n",
    "rf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "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>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>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1.1</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>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.3</td>\n",
       "      <td>2.7</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A    B  D\n",
       "0  1.2  2.3  0\n",
       "1  1.4  1.1  1\n",
       "2  2.5  3.0  1\n",
       "3  3.3  2.7  0"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[rf]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Before Reduct Computation:       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\n",
      "Actual Class labels:  ['L', 'R']\n",
      "\n",
      "Actual Dataset: \n",
      "      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\n",
      "\n",
      "Discretized Dataset: \n",
      " [[1. 2. 1. 1.]\n",
      " [1. 1. 1. 3.]\n",
      " [2. 3. 1. 3.]\n",
      " [3. 3. 1. 1.]]\n",
      "\n",
      "Discernibilty Matrix Processing...\n",
      "2-1:B\n",
      "3-1:A\n",
      "3-1:A B\n",
      "4-2:A\n",
      "4-2:A B\n",
      "4-3:A\n",
      "\n",
      "Valid entries in Discernibilty Matrix:  ['B', 'A B', 'A B', 'A']\n",
      "\n",
      "CORE(s):  ['B', 'A']\n",
      "\n",
      "REDUCT:  A B\n",
      "\n",
      "After Reduct Computation:       A    B  D\n",
      "0  1.2  2.3  0\n",
      "1  1.4  1.1  1\n",
      "2  2.5  3.0  1\n",
      "3  3.3  2.7  0\n",
      "\n",
      "Obtained Reduct is:  ['A', 'B']\n"
     ]
    }
   ],
   "source": [
    "########################## Classical Discernibility Matrix: Reduct ###############################\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import pandas as pd \n",
    "from sklearn import preprocessing\n",
    "from sklearn.preprocessing import KBinsDiscretizer\n",
    "import numpy as np\n",
    "  \n",
    "def my_discrn_mat(df,nbin):\n",
    "    \n",
    "    \n",
    "    # creating instance of labelencoder\n",
    "    labelencoder = preprocessing.LabelEncoder()\n",
    "    labelencoder.fit(df['D'])\n",
    "    print('Actual Class labels: ',list(labelencoder.classes_))\n",
    "\n",
    "    # Assigning numerical values and storing in another column\n",
    "    df['D'] = labelencoder.fit_transform(df['D'])\n",
    "    print('\\nActual Dataset: \\n',df)\n",
    "    \n",
    "    X=df.to_numpy()\n",
    "    # transform the dataset with KBinsDiscretizer\n",
    "    enc = KBinsDiscretizer(n_bins=3, encode='ordinal',strategy='uniform')\n",
    "    X_binned = enc.fit_transform(X.tolist())\n",
    "    X_binned=X_binned+1\n",
    "    print('\\nDiscretized Dataset: \\n', X_binned)\n",
    "    \n",
    "    r,c = X_binned.shape\n",
    "    f = ['A','B','C']\n",
    "    D = []\n",
    "  \n",
    "    # Create DataFrame \n",
    "    dfm = pd.DataFrame(M) \n",
    "    print('\\nDiscernibilty Matrix Processing...')\n",
    "    for i in range(r):\n",
    "        for j in range(r):\n",
    "            if i>j and X_binned[i][-1]!=X_binned[j][-1]:\n",
    "                str1=''\n",
    "                temp=[]\n",
    "                fg=0\n",
    "                for k in range(c-1):\n",
    "                    if X_binned[i][k]!=X_binned[j][k]:\n",
    "                        if k==0 or str1==\"\":\n",
    "                            str1 = str1+f[k]\n",
    "                            print('{}-{}:{}'.format(i+1,j+1,str1))\n",
    "                        else:\n",
    "                            str1 = str1+\" \"+f[k]\n",
    "                            print('{}-{}:{}'.format(i+1,j+1,str1))\n",
    "             \n",
    "                D.append(str1)\n",
    "\n",
    "    print('\\nValid entries in Discernibilty Matrix: ',D)\n",
    "    \n",
    "    l=len(D)\n",
    "    core =[]\n",
    "    for i in range(l):\n",
    "        if len(D[i])==1:\n",
    "            core.append(D[i])\n",
    "    \n",
    "    print('\\nCORE(s): ',core)\n",
    "    \n",
    "    t=len(core)\n",
    "    reduct=[]\n",
    "    for i in range(l):\n",
    "        c=0\n",
    "        for j in range(t):\n",
    "            if D[i].find(core[j]) != -1 and len(D[i])>1:\n",
    "                c=c+1\n",
    "            \n",
    "        if c==t:\n",
    "            reduct=D[i]\n",
    "            \n",
    "    print('\\nREDUCT: ',reduct)\n",
    "    \n",
    "    rf=reduct.split(\" \")\n",
    "    rf.append(\"D\")\n",
    "    \n",
    "    return df[rf], rf[:-1]\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,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",
    "  \n",
    "# Print the output. \n",
    "print('\\nBefore Reduct Computation: ',df) \n",
    "rdf, rf = my_discrn_mat(df,nbin=3) \n",
    "print('\\nAfter Reduct Computation: ',rdf) \n",
    "print('\\nObtained Reduct is: ',rf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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",
      "Actual Class labels:  ['L', 'R']\n",
      "\n",
      "Actual Dataset: \n",
      "      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  2.0  2.5  1\n",
      "3  3.3  2.7  2.5  0\n",
      "\n",
      "Discretized Dataset: \n",
      " [[1. 3. 1. 1.]\n",
      " [1. 1. 1. 3.]\n",
      " [2. 2. 1. 3.]\n",
      " [3. 3. 1. 1.]]\n",
      "\n",
      "Discernibilty Matrix Processing...\n",
      "2-1:B\n",
      "3-1:A B\n",
      "3-2:Φ\n",
      "4-1:Φ\n",
      "4-2:A B\n",
      "4-3:A B\n",
      "\n",
      "Valid entries in Discernibilty Matrix:  ['B', 'A B', 'A B', 'A B']\n",
      "\n",
      "CORE(s):  ['B']\n",
      "\n",
      "REDUCT:  A B\n",
      "\n",
      "After Reduct Computation: \n",
      "      A    B  D\n",
      "0  1.2  2.3  0\n",
      "1  1.4  1.1  1\n",
      "2  2.5  2.0  1\n",
      "3  3.3  2.7  0\n",
      "\n",
      "Obtained Reduct is:  ['A', 'B']\n",
      "\n",
      "Total execution time for DM: 0.004498 seconds\n"
     ]
    }
   ],
   "source": [
    "#### Calling Discernibility Matrix-based features selection Algorithm (iff features set is <= 26, that is, A to Z) ####\n",
    "\n",
    "import pandas as pd \n",
    "import time\n",
    "import my_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",
    "nbin=3\n",
    "\n",
    "# Print the output. \n",
    "print('\\nBefore Reduct Computation: \\n',df) \n",
    "t1=time.time()\n",
    "rdf, rf = my_discrn_mat.my_discrn_mat(df,nbin) \n",
    "t2=time.time()-t1\n",
    "print('\\nAfter Reduct Computation: \\n',rdf) \n",
    "print('\\nObtained Reduct is: ',rf)\n",
    "print('\\nTotal execution time for DM: {:.6f} seconds'.format(t2))"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}