Evaluation_new.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_result(class_num,ins_num):\n",
    "    result = [tuple(np.random.randint(0,class_num,2)) for i in range (ins_num)]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2, 1), (0, 0), (2, 0), (1, 0), (2, 0), (2, 1), (0, 0), (1, 1), (2, 2), (1, 0), (1, 1), (2, 0), (0, 2), (1, 1), (1, 0), (0, 1), (1, 2), (0, 1), (2, 1), (2, 1)]\n"
     ]
    }
   ],
   "source": [
    "method1 = generate_result(3, 20)\n",
    "print(method1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (2, 1), (1, 1), (2, 2), (0, 0), (0, 2), (1, 1), (0, 2), (2, 2), (1, 0), (1, 2), (2, 2), (0, 2), (0, 0), (2, 0), (2, 1), (1, 0), (0, 0), (0, 0), (1, 2)]\n"
     ]
    }
   ],
   "source": [
    "method2 = generate_result(3, 20)\n",
    "print(method2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Evaluation:\n",
    "    num_of_class = 0\n",
    "    num_of_inst = 0\n",
    "    result = []\n",
    "    multiclass_matrix=None\n",
    "    correct_pre = []\n",
    "    actual_num = []\n",
    "    predict_num = []\n",
    "    \n",
    "    def __init__(self,result,num_of_class):\n",
    "        self.result = result\n",
    "        self.num_of_class = num_of_class\n",
    "        self.num_of_inst = len(result)\n",
    "        self.multiclass_matrix = self.generate_matrix()\n",
    "        self.precess_matrix()\n",
    "    \n",
    "    def generate_matrix(self):\n",
    "        matrix = np.zeros((self.num_of_class, self.num_of_class))\n",
    "        for tup in self.result:\n",
    "            matrix[tup[0]][tup[1]]+=1\n",
    "        return matrix\n",
    "    \n",
    "    def precess_matrix(self):\n",
    "        self.correct_pre = [self.multiclass_matrix[i][i] for i in range(self.num_of_class)]\n",
    "        self.actual_num = [self.multiclass_matrix[i].sum() for i in range(self.num_of_class)]\n",
    "        self.predict_num = [self.multiclass_matrix[:,i].sum() for i in range(self.num_of_class)]\n",
    "    \n",
    "    \n",
    "    def calculate_accuracy(self):\n",
    "        accuracy = sum(self.correct_pre)/sum(self.actual_num)\n",
    "        return accuracy\n",
    "    \n",
    "    def calculate_Macro_value(self):\n",
    "        ###precision###\n",
    "        precision = sum([self.correct_pre[i]/self.predict_num[i] for i in range(self.num_of_class)])/self.num_of_class\n",
    "        ###recall###\n",
    "        recall = sum([self.correct_pre[i]/self.actual_num[i] for i in range(self.num_of_class)])/self.num_of_class\n",
    "        return [precision, recall]\n",
    "    \n",
    "    \n",
    "    def calculate_Micro_value(self):\n",
    "        ###precision###\n",
    "        precision = sum(self.correct_pre)/sum(self.predict_num)\n",
    "        ###recall###\n",
    "        recall = sum(self.correct_pre)/sum(self.actual_num)\n",
    "        return [precision, recall]\n",
    "    \n",
    "    def calculate_weight_value(self):\n",
    "        ###precision###\n",
    "        precision = sum([(self.actual_num[i]/self.num_of_inst)*(self.correct_pre[i]/self.predict_num[i])for i in range(self.num_of_class)])\n",
    "        ###recall###\n",
    "        recall = sum([(self.actual_num[i]/self.num_of_inst)*(self.correct_pre[i]/self.actual_num[i])for i in range(self.num_of_class)])\n",
    "        return [precision, recall]\n",
    "        \n",
    "        \n",
    "    def draw_heatmap_d(self):\n",
    "        sns.heatmap(self.multiclass_matrix, vmin=0, vmax=len(self.result), annot=True,cmap=\"RdPu_r\", fmt='.20g')\n",
    "        plt.show()\n",
    "        \n",
    "    def draw_heatmap_f(self):\n",
    "        sns.heatmap(self.multiclass_matrix/len(self.result), vmin=0, vmax=1, annot=True,cmap=\"RdPu_r\", fmt='.2g')\n",
    "        plt.show()  \n",
    "        \n",
    "    def draw_bar_chart(self):\n",
    "        names = [\"calss\"+str(i) for i in range(self.num_of_class)]\n",
    "        plt.figure(figsize=(10,6), dpi=80)\n",
    "        x = range(len(names))\n",
    "        \n",
    "        plt.bar(x, self.actual_num, width=0.1)\n",
    "        plt.bar([i + 0.1 for i in x], self.predict_num, width=0.1)\n",
    "        plt.bar([i + 0.2 for i in x], self.correct_pre, width=0.1)\n",
    "\n",
    "        plt.xticks([i + 0.05 for i in x], names)\n",
    "        \n",
    "        plt.xlabel('Class Name', fontsize=14)\n",
    "        plt.ylabel('Number Of Each Class', fontsize=14)\n",
    "        plt.show()\n",
    "        \n",
    "        \n",
    "    def evaluate(self):\n",
    "        ################################Calculate Accuracy##################################\n",
    "        accuracy = self.calculate_accuracy()\n",
    "        \n",
    "        print(\"accuracy is: %f\" %accuracy)\n",
    "        print(\"error rate is: %f\"%(1-accuracy))\n",
    "\n",
    "        ##macro averaging\n",
    "        precisionMa, recallMa = self.calculate_Macro_value()\n",
    "        print(\"Marco averaging precision is: %f\" %precisionMa)\n",
    "        print(\"Marco averaging recall is: %f\" %recallMa)\n",
    "        \n",
    "        #micro averaging\n",
    "        precisionMi, recallMi = self.calculate_Micro_value()\n",
    "        print(\"Mirco averaging precision is: %f\" %precisionMi)\n",
    "        print(\"Mirco averaging recall is: %f\" %recallMi)\n",
    "        \n",
    "        #weight averaging\n",
    "        precisionWe, recallWe = self.calculate_weight_value()\n",
    "        print(\"weight averaging precision is: %f\" %precisionWe)\n",
    "        print(\"weight averaging recall is: %f\" %recallWe)\n",
    "        \n",
    "        ###################################Draw Graphs######################################\n",
    "        #self.draw_heatmap_d()\n",
    "        #self.draw_heatmap_f()\n",
    "        #self.draw_bar_chart()\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluation1 = Evaluation(method1, 3)\n",
    "evaluation2 = Evaluation(method2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#这里使用Macro Averaging\n",
    "accuracy1 = evaluation1.calculate_accuracy()\n",
    "accuracy2 = evaluation2.calculate_accuracy()\n",
    "precision1,recall1 = evaluation1.calculate_Macro_value()\n",
    "precision2,recall2 = evaluation2.calculate_Macro_value()\n",
    "\n",
    "value_names = ['accuracy', 'precision','recall']\n",
    "values1 = [accuracy1,precision1,recall1]\n",
    "values2 = [accuracy2,precision2,recall2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#draw the bar chart\n",
    "plt.figure(figsize=(10,6), dpi=80)\n",
    "x = range(len(value_names))\n",
    "\n",
    "m1 = plt.bar(x, values1, width=0.1)\n",
    "m2 = plt.bar([i + 0.1 for i in x], values2, width=0.1)\n",
    "\n",
    "plt.xticks([i + 0.05 for i in x], value_names)\n",
    "plt.legend((m1,m2),(\"method1\",\"method2\"), loc=\"upper right\")\n",
    "\n",
    "def autolabel(rects): \n",
    "    for rect in rects:\n",
    "        height = rect.get_height()\n",
    "        plt.text(rect.get_x()+rect.get_width()/2., 1.03*height, '%s' % float(height))\n",
    "\n",
    "autolabel(m1)\n",
    "autolabel(m2)\n",
    "\n",
    "plt.xlabel('value name', fontsize=14)\n",
    "plt.ylabel('precentage', fontsize=14)\n",
    "plt.show()\n"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}