TeamEbrahimimehr_Tamrin3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import networkx as nx\n",
    "from collections import Counter\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set_style('white')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "df_iris = pd.read_csv('iris.txt', sep= ',', header= None)\n",
    "df_iris.head()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Calculating similarities between samples"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## defining function for calculating similarity"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def calculate_similarity(A, B, std):\n",
    "    '''The function definition fgoes here.'''\n",
    "    from numpy.linalg import norm\n",
    "    return np.exp(np.divide(norm(np.subtract(A, B))**2, -2 * std**2))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Calculating IRIS standard deviation"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "std = 0.73"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Calculating similarities"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "similarity_values = np.zeros((len(df_iris), len(df_iris)))\n",
    "similarity_values.fill(np.nan)\n",
    "for i in range(len(df_iris)):\n",
    "    for j in range(i + 1, len(df_iris)):\n",
    "        similarity_values[i, j] = np.round(calculate_similarity(df_iris.loc[i][:4], df_iris.loc[j][:4], std), 3)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Calculating mean & standard deviation of similarities"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "similarity_mean = np.round(np.nanmean(similarity_values), 3)\n",
    "similarity_std = np.round(np.nanstd(similarity_values), 3)\n",
    "print(f'Similarity mean: {similarity_mean}, std: {similarity_std}')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Calculating adjacent matrix based on similarities"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Defining the threshold"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "threshold = np.round(similarity_mean + (2 * similarity_std), 3)\n",
    "threshold"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Producing adjacent matrix based on threshold value"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "adjacent = np.copy(similarity_values)\n",
    "adjacent = np.where(adjacent >= threshold, 1, 0)\n",
    "adjacent[np.isnan(adjacent)] = 0\n",
    "print('Number of edges: ', adjacent.sum())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Graph analysis"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "adjacent_df = pd.DataFrame(adjacent.T + adjacent)\n",
    "# adjacent_df = adjacent_df.loc[adjacent_df.sum() != 0, adjacent_df.sum() != 0 ]\n",
    "adjacent_df.shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Calculating degree of nodes"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "degree_of_nodes = adjacent_df.sum().to_dict()\n",
    "mean_of_degree = np.sum(list(degree_of_nodes.values()))/ 150.0\n",
    "print('Mean of nodes degree: ', np.round(mean_of_degree, 3))\n",
    "plt.bar(degree_of_nodes.keys(), degree_of_nodes.values())\n",
    "plt.title('The Degree of Nodes in IRIS Similarity Graph')\n",
    "plt.xlabel('Nodes')\n",
    "plt.ylabel('Degree')\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Representing degree sequence"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "degree_sequence = dict(sorted(degree_of_nodes.items(), key=lambda item: item[1], reverse= True))\n",
    "print(list(degree_sequence.values()))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Representing degree distribution"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "degree_distribution = Counter(degree_sequence.values())\n",
    "plt.bar(degree_distribution.values(), degree_distribution.values())\n",
    "plt.title('The Degree Distribution of IRIS Similarity Graph')\n",
    "plt.xlabel('Degree of Nodes')\n",
    "plt.ylabel('Degree Frequencies')\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Representing degree probability mass function (PMF)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "pmf = {d: np.round(nk / 150, 3) for d, nk in degree_distribution.items()}\n",
    "plt.bar(pmf.keys(), pmf.values())\n",
    "plt.title('The PMF of Degree of the Nodes of IRIS Similarity Graph ')\n",
    "plt.xlabel('Degree')\n",
    "plt.ylabel('Degree Probabilities')\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Calculating path average of the graph"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "G = nx.from_pandas_adjacency(adjacent_df, create_using= nx.DiGraph)\n",
    "print('Number of strongly connected components in the IRIS graph', nx.number_strongly_connected_components(G))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Extracting Components"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "graphs = nx.condensation(G)\n",
    "component_0 = graphs.nodes.data()[0]['members']\n",
    "component_1 = graphs.nodes.data()[1]['members']\n",
    "G0 = G.subgraph(component_0)\n",
    "G1 = G.subgraph(component_1)\n",
    "print('Diameter of component_0: ', nx.diameter(G0), end= '')\n",
    "print(' Radius of component_0: ', nx.radius(G0))\n",
    "print('Diameter of component_1: ', nx.diameter(G1), end= '')\n",
    "print('  Radius of component_1: ', nx.radius(G1))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Average shortest path for each component"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print('Path average for component_0: ', np.round(nx.average_shortest_path_length(G0), 2))\n",
    "print('Path average for component_1: ', np.round(nx.average_shortest_path_length(G1), 2))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercises"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Exercise1 : Draw the calculated adjacency matrix(graph) with networkx library"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from decimal import *\n",
    "g = nx.from_pandas_adjacency(adjacent_df)\n",
    "pos = nx.spring_layout(g)\n",
    "x, y = 1, 1\n",
    "for i in range(0,150):\n",
    "    pos[i] = [float(x),float(y)]\n",
    "    if x < -0.39:\n",
    "        y-= Decimal(0.1)\n",
    "        x = 1\n",
    "    else: x-= Decimal(0.1)\n",
    "nx.draw(g ,pos=pos ,alpha=0.9 ,width=0.8 ,with_labels=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Exercise2: Draw each IRIS class with different node shapes from the calculated graph"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "list_1 = []\n",
    "list_2 = []\n",
    "list_3 = []\n",
    "for i in range(0, 150):\n",
    "    if df_iris.loc[i][4] == 'Iris-setosa':\n",
    "        list_1.append(i)\n",
    "    elif df_iris.loc[i][4] == 'Iris-virginica':\n",
    "        list_2.append(i)\n",
    "    elif df_iris.loc[i][4] == 'Iris-versicolor':\n",
    "        list_3.append(i)\n",
    "subgraph_1 = nx.subgraph(g ,list_1)\n",
    "subgraph_2 = nx.subgraph(g ,list_2)\n",
    "subgraph_3 = nx.subgraph(g ,list_3)\n",
    "nx.draw(subgraph_1 ,pos=pos ,node_shape='o' ,node_color='red' ,alpha=0.9 ,width=0.8 ,with_labels=True)\n",
    "nx.draw(subgraph_2 ,pos=pos ,node_shape='s' ,node_color='green' ,alpha=0.9 ,width=0.8 ,with_labels=True)\n",
    "nx.draw(subgraph_3 ,pos=pos ,node_shape='p' ,node_color='orange' ,alpha=0.9 ,width=0.8 ,with_labels=True)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Exercise3: Draw degree distribution of the calculated graph"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}