fuzzy c-means .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing the libraries and setting parameter values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Importing the required Libraries\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import operator\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of Attributes\n",
    "num_attr = len(df.columns) - 1\n",
    "\n",
    "# Number of Clusters to make\n",
    "k = 2\n",
    "\n",
    "# Maximum number of iterations\n",
    "MAX_ITER = 100\n",
    "\n",
    "# Number of data points\n",
    "n = len(df)\n",
    "\n",
    "# Fuzzy parameter\n",
    "m = 2.00"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading the Input Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "### reading the input csv file \n",
    "\n",
    "df_full = pd.read_csv(\"Data.csv\")\n",
    "columns = list(df_full.columns)\n",
    "features = columns[:len(columns)-1]\n",
    "class_labels = list(df_full[columns[-1]])\n",
    "df = df_full[features]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utility Function for Evaluating the Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### accuracy function for measuring the accuracy of our result\n",
    "\n",
    "def accuracy(cluster_labels, class_labels):\n",
    "    county = [0,0]\n",
    "    countn = [0,0]\n",
    "    tp = [0, 0]\n",
    "    tn = [0, 0]\n",
    "    fp = [0, 0]\n",
    "    fn = [0, 0]\n",
    "    \n",
    "    for i in range(len(df)):\n",
    "        # Yes = 1, No = 0\n",
    "        if cluster_labels[i] == 1 and class_labels[i] == 'Yes':\n",
    "            tp[0] = tp[0] + 1\n",
    "        if cluster_labels[i] == 0 and class_labels[i] == 'No':\n",
    "            tn[0] = tn[0] + 1\n",
    "        if cluster_labels[i] == 1 and class_labels[i] == 'No':\n",
    "            fp[0] = fp[0] + 1\n",
    "        if cluster_labels[i] == 0 and class_labels[i] == 'Yes':\n",
    "            fn[0] = fn[0] + 1\n",
    "    \n",
    "    for i in range(len(df)):\n",
    "        # Yes = 0, No = 1\n",
    "        if cluster_labels[i] == 0 and class_labels[i] == 'Yes':\n",
    "            tp[1] = tp[1] + 1\n",
    "        if cluster_labels[i] == 1 and class_labels[i] == 'No':\n",
    "            tn[1] = tn[1] + 1\n",
    "        if cluster_labels[i] == 0 and class_labels[i] == 'No':\n",
    "            fp[1] = fp[1] + 1\n",
    "        if cluster_labels[i] == 1 and class_labels[i] == 'Yes':\n",
    "            fn[1] = fn[1] + 1\n",
    "    \n",
    "    a0 = float((tp[0] + tn[0]))/(tp[0] + tn[0] + fn[0] + fp[0])\n",
    "    a1 = float((tp[1] + tn[1]))/(tp[1] + tn[1] + fn[1] + fp[1])\n",
    "    p0 = float(tp[0])/(tp[0] + fp[0])\n",
    "    p1 = float(tp[1])/(tp[1] + fp[1])\n",
    "    r0 = float(tp[0])/(tp[0] + fn[0])\n",
    "    r1 = float(tp[1])/(tp[1] + fn[1])\n",
    "    \n",
    "    accuracy = [a0*100,a1*100]\n",
    "    precision = [p0*100,p1*100]\n",
    "    recall = [r0*100,r1*100]\n",
    "    \n",
    "    return accuracy, precision, recall\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fuzzy C-means Algorithm\n",
    "### Step 1 : Initializing the Membership Matrix with Random Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "### initializing the membership matrix with random values\n",
    "\n",
    "def initializeMembershipMatrix():\n",
    "    membership_mat = list()\n",
    "    for i in range(n):\n",
    "        random_num_list = [random.random() for i in range(k)]\n",
    "        summation = sum(random_num_list)\n",
    "        temp_list = [x/summation for x in random_num_list]\n",
    "        membership_mat.append(temp_list)\n",
    "    return membership_mat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2 : Calculating the Cluster Center"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "### calculating the cluster center, is done in every iteration\n",
    "\n",
    "def calculateClusterCenter(membership_mat):\n",
    "    cluster_mem_val = zip(*membership_mat)\n",
    "    cluster_centers = list()\n",
    "    for j in range(k):\n",
    "        x = list(cluster_mem_val[j])\n",
    "        xraised = [e ** m for e in x]\n",
    "        denominator = sum(xraised)\n",
    "        temp_num = list()\n",
    "        for i in range(n):\n",
    "            data_point = list(df.iloc[i])\n",
    "            prod = [xraised[i] * val for val in data_point]\n",
    "            temp_num.append(prod)\n",
    "        numerator = map(sum, zip(*temp_num))\n",
    "        center = [z/denominator for z in numerator]\n",
    "        cluster_centers.append(center)\n",
    "    return cluster_centers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3 : Updating Membership Values using Cluster Centers from Step 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "### updating the membership values using the cluster centers\n",
    "\n",
    "def updateMembershipValue(membership_mat, cluster_centers):\n",
    "    p = float(2/(m-1))\n",
    "    for i in range(n):\n",
    "        x = list(df.iloc[i])\n",
    "        distances = [np.linalg.norm(map(operator.sub, x, cluster_centers[j])) for j in range(k)]\n",
    "        for j in range(k):\n",
    "            den = sum([math.pow(float(distances[j]/distances[c]), p) for c in range(k)])\n",
    "            membership_mat[i][j] = float(1/den)       \n",
    "    return membership_mat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function defined which returns the Clusters from the Membership Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getClusters(membership_mat):\n",
    "    cluster_labels = list()\n",
    "    for i in range(n):\n",
    "        max_val, idx = max((val, idx) for (idx, val) in enumerate(membership_mat[i]))\n",
    "        cluster_labels.append(idx)\n",
    "    return cluster_labels\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling fcm function which runs for MAX_ITER number of times and returns the Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "### the final fcm function, \n",
    "\n",
    "def fuzzyCMeansClustering():\n",
    "    # Membership Matrix\n",
    "    membership_mat = initializeMembershipMatrix()\n",
    "    curr = 0\n",
    "    while curr <= MAX_ITER:\n",
    "        cluster_centers = calculateClusterCenter(membership_mat)\n",
    "        membership_mat = updateMembershipValue(membership_mat, cluster_centers)\n",
    "        cluster_labels = getClusters(membership_mat)\n",
    "        curr += 1\n",
    "    \n",
    "    print(membership_mat)\n",
    "    return cluster_labels, cluster_centers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying the Results\n",
    "### Outputting Cluster Labels and Cluster Centers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "### calling the main function and storing the final results in labels, centers\n",
    "\n",
    "print(\"printing the final membership matrix\")\n",
    "\n",
    "labels, centers = fuzzyCMeansClustering()\n",
    "\n",
    "print(\"printing cluster centers\")\n",
    "print(centers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Outputting the accuracy achieved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy = [74.54545454545455, 25.454545454545453]\n",
      "Precision = [88.57142857142857, 32.0]\n",
      "Recall = [56.36363636363636, 43.63636363636363]\n"
     ]
    }
   ],
   "source": [
    "### measuring the accuracy of the result\n",
    "\n",
    "a,p,r = accuracy(labels, class_labels)\n",
    "\n",
    "### printing the values\n",
    "\n",
    "print(\"Accuracy = \" + str(a))\n",
    "print(\"Precision = \" + str(p))\n",
    "print(\"Recall = \" + str(r))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}