F-Score from scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation of  F-Score + other values\n",
    "\n",
    "  Restrictions: \n",
    "   -\n",
    "\n",
    "    input: Matric [C,M] where CM[c,t] is the number of objects of class c that were classified as class t.\n",
    "    output: For each class compute Precision, Recall and F1-score. Also compute weighted average Precision, Recall, macro       F1-score and micro F1-score for all classes, where weight is a class distribution\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd\n",
    "from random import choice\n",
    "from string import ascii_lowercase\n",
    "\n",
    "classes = 5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   a  b  c  d  e\n",
      "a  3  0  9  1  2\n",
      "b  6  3  4  0  8\n",
      "c  6  8  5  2  8\n",
      "d  2  1  3  4  9\n",
      "e  5  7  4  0  8\n"
     ]
    }
   ],
   "source": [
    "CM = np.random.randint(10, size=(classes,classes))\n",
    "label = ''.join(['%c' % x for x in range(97, 97+classes)])   #useful!\n",
    "names = [_ for _ in label]\n",
    "df = pd.DataFrame(CM, index=names, columns=names)\n",
    "print(df)\n",
    "\n",
    "CM = np.array([[3,1,1],[3,1,1],[1,3,1]])   # use for specific input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class class_scorer:\n",
    "    def __init__(self,conM):\n",
    "        self.conf = conM\n",
    "        self.weights = self.class_weights()\n",
    "        self.prec = self.precision()\n",
    "        self.rec = self.recall()\n",
    "        self.f1 = self.f1_measure()\n",
    "        self.wprec = self.weighted_precision()\n",
    "        self.wrec = self.weighted_recall()\n",
    "        self.macroF1 = self.weighted_f1_macro()\n",
    "        self.microF1 = self.weighted_f1_micro()\n",
    "        \n",
    "    def class_weights(self):\n",
    "        weights = []\n",
    "        for x in range(len(self.conf[0])):\n",
    "            weight = sum(self.conf[x])\n",
    "            weights.append(weight)\n",
    "        return weights\n",
    "            \n",
    "        \n",
    "    def precision(self):\n",
    "        prec = []\n",
    "        for x in range(len(self.conf[0])):\n",
    "            FPTP = 0 \n",
    "            for y in range(len(self.conf)):\n",
    "                FPTP = FPTP + self.conf[y][x]\n",
    "            if FPTP == 0:\n",
    "                prec.append(0.0)\n",
    "            else:\n",
    "                precision = self.conf[x][x] / FPTP\n",
    "                prec.append(precision)\n",
    "        return prec\n",
    "    def recall(self):\n",
    "        rec = []\n",
    "        for x in range(len(self.conf[0])):\n",
    "            TPFN = sum(self.conf[x])\n",
    "            if TPFN == 0: \n",
    "                rec.append(0.0)\n",
    "            else:\n",
    "                recall = self.conf[x][x] / TPFN\n",
    "                rec.append(recall)\n",
    "        return rec\n",
    "    def f1_measure(self):\n",
    "        scores = []\n",
    "        for x in range(len(self.conf[0])):\n",
    "            if self.prec[x] == 0 and self.rec[x] == 0 :\n",
    "                score = 0.0\n",
    "            else: \n",
    "                score = 2*(self.rec[x] * self.prec[x]) / (self.rec[x] + self.prec[x])\n",
    "            scores.append(score)\n",
    "        return scores\n",
    "   \n",
    "        \n",
    "    def weighted_precision(self):\n",
    "        wPrec = map(lambda x, y: x * y, self.prec, self.weights) \n",
    "        if sum(self.weights) > 0: \n",
    "            return sum(wPrec)/sum(self.weights)\n",
    "        else:\n",
    "            return (0.0)\n",
    "    \n",
    "    def weighted_recall(self):\n",
    "        wRec = map(lambda x, y: x * y, self.rec, self.weights) \n",
    "        if sum(self.weights) >0: \n",
    "            return sum(wRec)/sum(self.weights)\n",
    "        else:\n",
    "            return(0.0)\n",
    "        \n",
    "    def weighted_f1_macro(self):# standard is unweighted like in sklearn\n",
    "            if self.wrec == 0 and self.wprec == 0:\n",
    "                return 0.0\n",
    "            else:\n",
    "                score = 2*(self.wrec* self.wprec) / (self.wrec + self.wprec)\n",
    "            return score\n",
    "         \n",
    "    \n",
    "    def weighted_f1_micro(self):\n",
    "        wF1 = map(lambda x, y: x * y, self.f1, self.weights) \n",
    "        if sum(self.weights)== 0:\n",
    "            return 0.0\n",
    "        else:\n",
    "            micro = (sum(wF1))/(sum(self.weights))\n",
    "        return micro\n",
    "    \n",
    "    def format_results (self):\n",
    "        out = np.matrix([self.prec,self.rec,self.f1])\n",
    "        out = np.transpose(out)\n",
    "        label = ''.join(['%c' % x for x in range(97, 97+len(self.conf))])   #useful!\n",
    "        names = [_ for _ in label]\n",
    "        df = pd.DataFrame(out, index=names, columns=[\"Recall\",\"Precision\",\"F1\"])\n",
    "        weighted = [self.wprec,self.wrec,self.macroF1,self.microF1]\n",
    "        df2 = pd.DataFrame(weighted, columns = [\"X\"], index = [\"weighted Recall\",\"weighted Precision\",\"macro F1\",\"micro F1\"])\n",
    "        print(df2)\n",
    "        return df.style\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           X\n",
      "weighted Recall     0.320635\n",
      "weighted Precision  0.333333\n",
      "macro F1            0.326861\n",
      "micro F1            0.316667\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "</style>  \n",
       "<table id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142c\" > \n",
       "<thead>    <tr> \n",
       "        <th class=\"blank level0\" ></th> \n",
       "        <th class=\"col_heading level0 col0\" >Recall</th> \n",
       "        <th class=\"col_heading level0 col1\" >Precision</th> \n",
       "        <th class=\"col_heading level0 col2\" >F1</th> \n",
       "    </tr></thead> \n",
       "<tbody>    <tr> \n",
       "        <th id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142clevel0_row0\" class=\"row_heading level0 row0\" >a</th> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow0_col0\" class=\"data row0 col0\" >0.428571</td> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow0_col1\" class=\"data row0 col1\" >0.6</td> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow0_col2\" class=\"data row0 col2\" >0.5</td> \n",
       "    </tr>    <tr> \n",
       "        <th id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142clevel0_row1\" class=\"row_heading level0 row1\" >b</th> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow1_col0\" class=\"data row1 col0\" >0.2</td> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow1_col1\" class=\"data row1 col1\" >0.2</td> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow1_col2\" class=\"data row1 col2\" >0.2</td> \n",
       "    </tr>    <tr> \n",
       "        <th id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142clevel0_row2\" class=\"row_heading level0 row2\" >c</th> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow2_col0\" class=\"data row2 col0\" >0.333333</td> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow2_col1\" class=\"data row2 col1\" >0.2</td> \n",
       "        <td id=\"T_b7ed1d94_4ca3_11e9_a60d_144f8a96142crow2_col2\" class=\"data row2 col2\" >0.25</td> \n",
       "    </tr></tbody> \n",
       "</table> "
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x1a5544e36a0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test= class_scorer(CM)\n",
    "test.format_results()\n",
    "\n",
    "\n",
    "#TODO --> catch all NANs"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}