Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.io\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "import math\n",
    "from scipy import stats\n",
    "from itertools import chain, combinations, product, compress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise #1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "D1 = scipy.io.loadmat('data/D1.mat')[\"D\"]\n",
    "D2 = scipy.io.loadmat('data/D2.mat')[\"D\"]\n",
    "D3 = scipy.io.loadmat('data/D3.mat')[\"D\"]\n",
    "D4 = scipy.io.loadmat('data/D4.mat')[\"D\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_combinations(items):\n",
    "    return list(set(compress(items,mask)) for mask in product(*[[0,1]]*len(items)))\n",
    "\n",
    "def min_d_num(G, graph_nodes):\n",
    "    minimum_n = []\n",
    "    for N in graph_nodes:\n",
    "        neigh = list(G.neighbors(N))\n",
    "        minimum_n.append(len(neigh))\n",
    "    return max(minimum_n)\n",
    "\n",
    "def ci_test(D, X, Y, Z):\n",
    "    alpha = 0.06\n",
    "    n = D.shape[0]\n",
    "    if len(Z) == 0:\n",
    "        r = np.corrcoef(D[:, [X, Y]].T)[0][1]\n",
    "    else:\n",
    "        sub_index = [X, Y]\n",
    "        sub_index.extend(Z)\n",
    "        sub_corr = np.corrcoef(D[:, sub_index].T)\n",
    "        # inverse matrix\n",
    "        try:\n",
    "            PM = np.linalg.inv(sub_corr)\n",
    "        except np.linalg.LinAlgError:\n",
    "            PM = np.linalg.pinv(sub_corr)\n",
    "        r = -1 * PM[0, 1] / math.sqrt(abs(PM[0, 0] * PM[1, 1]))\n",
    "    cut_at = 0.99999\n",
    "    r = min(cut_at, max(-1 * cut_at, r))  # make r between -1 and 1\n",
    "\n",
    "    # Fisher’s z-transform\n",
    "    res = math.sqrt(n - len(Z) - 3) * .5 * math.log1p((2 * r) / (1 - r))\n",
    "    p_value = 2 * (1 - stats.norm.cdf(abs(res)))\n",
    "\n",
    "    return p_value >= alpha\n",
    "\n",
    "def SGS_new(matrix):\n",
    "    graph_nodes = list(range(matrix.shape[1]))\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(graph_nodes)\n",
    "    ci_number = 0\n",
    "    extracted_Z = []\n",
    "    checked_nodes = []\n",
    "    \n",
    "    for X in graph_nodes:\n",
    "        for Y in graph_nodes:\n",
    "            if X == Y: continue\n",
    "            elif [X, Y] in checked_nodes: continue\n",
    "            else:\n",
    "                V = list(range(matrix.shape[1]))\n",
    "                del V[V.index(X)]\n",
    "                del V[V.index(Y)]\n",
    "                \n",
    "                ci_res = False\n",
    "\n",
    "                for Z in sorted(create_combinations(V), reverse = True):\n",
    "                    ci_res = ci_test(matrix, X, Y, list(Z))\n",
    "                    ci_number += 1\n",
    "                    checked_nodes.append([X, Y])\n",
    "                    checked_nodes.append([Y, X])\n",
    "                    if ci_res == True:\n",
    "                        extracted_Z.append([X, Y, list(Z)])\n",
    "                        break\n",
    "\n",
    "                if ci_res == False:\n",
    "                    G.add_edge(X,Y)\n",
    "                    \n",
    "    return nx.adjacency_matrix(G).todense(), extracted_Z, ci_number\n",
    "\n",
    "def PC1_new(matrix):\n",
    "    graph_nodes = list(range(matrix.shape[1]))\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(graph_nodes)\n",
    "    ci_number = 0\n",
    "    extracted_Z = []\n",
    "    checked_nodes = []\n",
    "    for X in graph_nodes:\n",
    "        for Y in graph_nodes:\n",
    "            if X == Y: continue\n",
    "            else:\n",
    "                G.add_edge(X,Y)\n",
    "\n",
    "    d = 0\n",
    "    while min_d_num(G, graph_nodes) >= d:\n",
    "        checked_nodes2 = []\n",
    "        for X in graph_nodes:\n",
    "            for Y in graph_nodes:\n",
    "                if X == Y:  continue\n",
    "                elif [X, Y] in checked_nodes or [X, Y] in checked_nodes2: continue\n",
    "                else:                  \n",
    "                    V = list(range(matrix.shape[1]))\n",
    "                    del V[V.index(X)]\n",
    "                    del V[V.index(Y)]\n",
    "\n",
    "                    for Z in combinations(V, d):\n",
    "                        Z = list(Z)\n",
    "                        ci_res = ci_test(matrix, X, Y, Z)\n",
    "                        ci_number += 1\n",
    "                        if ci_res == True:\n",
    "                            extracted_Z.append([X, Y, Z])\n",
    "                            G.remove_edge(X,Y)\n",
    "                            checked_nodes.append([X, Y])\n",
    "                            checked_nodes.append([Y, X])\n",
    "                            break\n",
    "                        else:\n",
    "                            checked_nodes2.append([X, Y])\n",
    "                            checked_nodes2.append([Y, X])                 \n",
    "            \n",
    "        d += 1\n",
    "    return nx.adjacency_matrix(G).todense(), extracted_Z, ci_number\n",
    "\n",
    "def PC2_new(matrix):\n",
    "    graph_nodes = list(range(matrix.shape[1]))\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(graph_nodes)\n",
    "    ci_number = 0\n",
    "    extracted_Z = []\n",
    "    checked_nodes = []\n",
    "    checked_nodes2 = []\n",
    "\n",
    "    d = 0\n",
    "    for X in graph_nodes:\n",
    "        for Y in graph_nodes:\n",
    "            if X == Y: continue\n",
    "            elif [X, Y] in checked_nodes: continue\n",
    "            else:\n",
    "                V = list(range(matrix.shape[1]))\n",
    "                del V[V.index(X)]\n",
    "                del V[V.index(Y)]\n",
    "\n",
    "                if ci_test(matrix, X, Y, V) == False:\n",
    "                    ci_number += 1\n",
    "                    G.add_edge(X,Y)\n",
    "                    checked_nodes.append([X, Y])\n",
    "                    checked_nodes.append([Y, X])\n",
    "    \n",
    "    while min_d_num(G, graph_nodes) >= d:\n",
    "        checked_nodes3 = []\n",
    "        for X in graph_nodes:\n",
    "            for Y in graph_nodes:\n",
    "                if X == Y: continue\n",
    "                elif [X, Y] in checked_nodes2 or [X, Y] in checked_nodes3: continue\n",
    "                elif G.has_edge(X,Y) == False: continue\n",
    "                else:\n",
    "                    V = list(range(matrix.shape[1]))\n",
    "                    del V[V.index(X)]\n",
    "                    del V[V.index(Y)]\n",
    "\n",
    "                    for Z in combinations(V, d):\n",
    "                        Z = list(Z)\n",
    "                        ci_res = ci_test(matrix, X, Y, Z)\n",
    "                        ci_number += 1\n",
    "                        if ci_res == True:\n",
    "                            extracted_Z.append([X, Y, Z])\n",
    "                            checked_nodes2.append([X,Y])\n",
    "                            checked_nodes2.append([Y,X])\n",
    "                            G.remove_edge(X,Y)\n",
    "                            break\n",
    "\n",
    "                        else:\n",
    "                            checked_nodes3.append([X, Y])\n",
    "                            checked_nodes3.append([Y, X])\n",
    "        d += 1\n",
    "    return nx.adjacency_matrix(G).todense(), extracted_Z, ci_number\n",
    "\n",
    "def retrieve_v_shape(MM, cond_sub):\n",
    "    GG = nx.from_numpy_matrix(MM, create_using= nx.DiGraph())\n",
    "    for X in range(len(MM)):\n",
    "        for Y in range(len(MM)):\n",
    "            if X == Y: continue\n",
    "            for W in range(len(MM)):\n",
    "                # Avoid to consider the same node\n",
    "                if W == Y or W == X: continue\n",
    "                else:\n",
    "                    # Check the link between X ans Y\n",
    "                    XY_link = GG.has_edge(X,Y)\n",
    "                    # Check the link between Y ans W\n",
    "                    YW_link = GG.has_edge(Y,W)\n",
    "                    # Check the link between W ans X\n",
    "                    WX_link = GG.has_edge(W,X)\n",
    "                    if XY_link == True and YW_link == True and WX_link == False:\n",
    "                        checker = []\n",
    "                        for i in cond_sub:\n",
    "                            if X == i[0] and W == i[1] and Y not in i[2]:\n",
    "                                # Z does not includes Y\n",
    "                                checker.append(True)\n",
    "                            elif X == i[0] and W == i[1] and Y in i[2]:\n",
    "                                # Z includes Y\n",
    "                                checker.append(False)\n",
    "                                break\n",
    "                        test = all(p == True for p in checker)\n",
    "\n",
    "                        if test is True and len(checker) > 0:\n",
    "                            # Remove the link Y --> X\n",
    "                            try:\n",
    "                                GG.remove_edge(Y, X)\n",
    "                            except nx.NetworkXError:\n",
    "                                None\n",
    "                            # Remove the link Y --> W\n",
    "                            try:\n",
    "                                GG.remove_edge(Y, W) \n",
    "                            except nx.NetworkXError:\n",
    "                                None\n",
    "\n",
    "    return nx.adjacency_matrix(GG).todense()\n",
    "\n",
    "def rulmk1 (MM):\n",
    "    GG = nx.from_numpy_matrix(MM, create_using= nx.DiGraph())\n",
    "    for A in range(len(MM)):\n",
    "        for B in range(len(MM)):\n",
    "            # Avoid to consider the same node\n",
    "            if A == B: continue\n",
    "            else:\n",
    "                # Check if there is the link A --> B\n",
    "                check_1 = GG.has_edge(A,B)\n",
    "                # Check if there is the link B --> A\n",
    "                check_2 = GG.has_edge(B,A)\n",
    "                if check_1 == True and check_2 == False:\n",
    "                    for C in range(len(MM)):\n",
    "                        # Avoid to consider the same node\n",
    "                        if C == A or C == B: continue\n",
    "                        else:\n",
    "                            # Check if there is the link B --> C\n",
    "                            check_3 = GG.has_edge(B,C)\n",
    "                            # Check if there is the link C --> B\n",
    "                            check_4 = GG.has_edge(C,B)\n",
    "                            # Check if there is the link A --> C\n",
    "                            check_5 = GG.has_edge(A,C)\n",
    "                            # Check if there is the link C --> A\n",
    "                            check_6 = GG.has_edge(C,A)\n",
    "                            \n",
    "                            # Check if there are all the conditions for Meek Rule #2\n",
    "                            if check_3 == True and check_4 == True and check_5 == False and check_6 == False:\n",
    "                                # Remove the link C --> B\n",
    "                                GG.remove_edge(C,B)\n",
    "\n",
    "    return nx.adjacency_matrix(GG).todense()\n",
    "\n",
    "def rulmk2 (MM):\n",
    "    GG = nx.from_numpy_matrix(MM, create_using= nx.DiGraph())\n",
    "    for A in range(len(MM)):\n",
    "        for B in range(len(MM)):\n",
    "            # Avoid to consider the same node\n",
    "            if A == B: continue\n",
    "            else:\n",
    "                # Check if there is the link A --> B\n",
    "                check_1 = GG.has_edge(A,B)\n",
    "                # Check if there is the link B --> A\n",
    "                check_2 = GG.has_edge(B,A)\n",
    "                # If there is only the link A --> B\n",
    "                if check_1 == True and check_2 == False:\n",
    "                    for C in range(len(MM)):\n",
    "                        # Avoid to consider the same node\n",
    "                        if C == A or C == B: continue\n",
    "                        else:\n",
    "                            # Check if there is the link B --> C\n",
    "                            check_3 = GG.has_edge(B,C)\n",
    "                            # Check if there is the link C --> B\n",
    "                            check_4 = GG.has_edge(C,B)\n",
    "                            # Check if there is the link A --> C\n",
    "                            check_5 = GG.has_edge(A,C)\n",
    "                            # Check if there is the link C --> A\n",
    "                            check_6 = GG.has_edge(C,A)\n",
    "\n",
    "                            # Check if there are all the conditions for Meek Rule #2\n",
    "                            if check_3 == True and check_4 == False and check_5 == True and check_6 == True:\n",
    "                                # Remove the link C --> A\n",
    "                                GG.remove_edge(C,A)\n",
    "    return nx.adjacency_matrix(GG).todense()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows = 3, ncols = 3, figsize=(20,20))\n",
    "ax = axes.flatten()\n",
    "\n",
    "## Database #1 - SGS algorithm\n",
    "SGS_M1, SGS_M1_Z, SGS_M1_t  = SGS_new(D1)\n",
    "SGS_M1 = rulmk2(rulmk1(retrieve_v_shape(SGS_M1, SGS_M1_Z)))\n",
    "SGS_G1 = nx.from_numpy_matrix(SGS_M1, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(SGS_G1, pos= nx.spring_layout(SGS_G1, seed = 2) , ax=ax[0], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[0].set_axis_off()\n",
    "title_SGS_M1 = \"Causal structure of dataset #1 using SGS algorithm\\n\" + \"N of tests performed:\" + str(SGS_M1_t)\n",
    "ax[0].set_title(title_SGS_M1)\n",
    "\n",
    "## Database #2 - SGS algorithm\n",
    "SGS_M2, SGS_M2_Z, SGS_M2_t = SGS_new(D2)\n",
    "SGS_M2 = rulmk2(rulmk1(retrieve_v_shape(SGS_M2, SGS_M2_Z)))\n",
    "SGS_G2 = nx.from_numpy_matrix(SGS_M2, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(SGS_G2, pos= nx.spring_layout(SGS_G2, seed = 2) , ax=ax[1], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[1].set_axis_off()\n",
    "title_SGS_G2 = \"Causal structure of dataset #2 using SGS algorithm\\n\" + \"N of tests performed:\" + str(SGS_M2_t)\n",
    "ax[1].set_title(title_SGS_G2)\n",
    "\n",
    "## Database #3 - SGS algorithm\n",
    "SGS_M3, SGS_M3_Z, SGS_M3_t = SGS_new(D3)\n",
    "SGS_M3 = rulmk2(rulmk1(retrieve_v_shape(SGS_M3, SGS_M3_Z)))\n",
    "SGS_G3 = nx.from_numpy_matrix(SGS_M3, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(SGS_G3, pos= nx.spring_layout(SGS_G3, seed = 28) , ax=ax[2], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[2].set_axis_off()\n",
    "title_SGS_G3 = \"Causal structure of dataset #3 using SGS algorithm\\n\" + \"N of tests performed:\" + str(SGS_M3_t)\n",
    "ax[2].set_title(title_SGS_G3)\n",
    "\n",
    "## Database #1 - PC1 algorithm\n",
    "PC1_M1, PC1_M1_Z, PC1_M1_t = PC1_new(D1)\n",
    "PC1_M1 = rulmk2(rulmk1(retrieve_v_shape(PC1_M1, PC1_M1_Z)))\n",
    "PC1_G1 = nx.from_numpy_matrix(PC1_M1, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(PC1_G1, pos= nx.spring_layout(PC1_G1, seed = 2) , ax=ax[3], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[3].set_axis_off()\n",
    "title_PC1_G1 = \"Causal structure of dataset #1 using PC1 algorithm\\n\" + \"N of tests performed:\" + str(PC1_M1_t)\n",
    "ax[3].set_title(title_PC1_G1)\n",
    "\n",
    "## Database #2 - PC1 algorithm\n",
    "PC1_M2, PC1_M2_Z, PC1_M2_t = PC1_new(D2)\n",
    "PC1_M2 = rulmk2(rulmk1(retrieve_v_shape(PC1_M2, PC1_M2_Z)))\n",
    "PC1_G2 = nx.from_numpy_matrix(PC1_M2, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(PC1_G2, pos= nx.spring_layout(PC1_G2, seed = 2) , ax=ax[4], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[4].set_axis_off()\n",
    "title_PC1_G1 = \"Causal structure of dataset #2 using PC1 algorithm\\n\" + \"N of tests performed:\" + str(PC1_M2_t)\n",
    "ax[4].set_title(title_PC1_G1)\n",
    "\n",
    "## Database #3 - PC1 algorithm\n",
    "PC1_M3, PC1_M3_Z, PC1_M3_t = PC1_new(D3)\n",
    "PC1_M3 = rulmk2(rulmk1(retrieve_v_shape(PC1_M3, PC1_M3_Z)))\n",
    "PC1_G3 = nx.from_numpy_matrix(PC1_M3, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(PC1_G3, pos= nx.spring_layout(PC1_G3, seed = 28) , ax=ax[5], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[5].set_axis_off()\n",
    "title_PC1_G3 = \"Causal structure of dataset #3 using PC1 algorithm\\n\" + \"N of tests performed:\" + str(PC1_M3_t)\n",
    "ax[5].set_title(title_PC1_G3)\n",
    "\n",
    "## Database #1 - PC2 algorithm\n",
    "PC2_M1, PC2_M1_Z, PC2_M1_t = PC2_new(D1)\n",
    "PC2_M1 = rulmk2(rulmk1(retrieve_v_shape(PC2_M1, PC2_M1_Z)))\n",
    "PC2_G1 = nx.from_numpy_matrix(PC2_M1, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(PC2_G1, pos= nx.spring_layout(PC2_G1, seed = 2) , ax=ax[6], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[6].set_axis_off()\n",
    "title_PC2_G1 = \"Causal structure of dataset #1 using PC2 algorithm\\n\" + \"N of tests performed:\" + str(PC2_M1_t)\n",
    "ax[6].set_title(title_PC2_G1)\n",
    "\n",
    "## Database #2 - PC2 algorithm\n",
    "PC2_M2, PC2_M2_Z, PC2_M2_t = PC2_new(D2)\n",
    "PC2_M2 = rulmk2(rulmk1(retrieve_v_shape(PC2_M2, PC2_M2_Z)))\n",
    "PC2_G2 = nx.from_numpy_matrix(PC2_M2, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(PC2_G2, pos= nx.spring_layout(PC2_G2, seed = 2) , ax=ax[7], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[7].set_axis_off()\n",
    "title_PC2_G2 = \"Causal structure of dataset #2 using PC2 algorithm\\n\" + \"N of tests performed:\" + str(PC2_M2_t)\n",
    "ax[7].set_title(title_PC2_G2)\n",
    "\n",
    "## Database #3 - PC2 algorithm\n",
    "PC2_M3, PC2_M3_Z, PC2_M3_t = PC2_new(D3)\n",
    "PC2_M3 = rulmk2(rulmk1(retrieve_v_shape(PC2_M3, PC2_M3_Z)))\n",
    "PC2_G3 = nx.from_numpy_matrix(PC2_M3, create_using = nx.DiGraph())\n",
    "nx.draw_networkx(PC2_G3, pos= nx.spring_layout(PC2_G3, seed = 28) , ax=ax[8], with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)\n",
    "ax[8].set_axis_off()\n",
    "title_PC2_G3 = \"Causal structure of dataset #3 using PC2 algorithm\\n\" + \"N of tests performed:\" + str(PC2_M3_t)\n",
    "ax[8].set_title(title_PC2_G3)                \n",
    "                \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<H2 style = \"color: red\">IMPORTANT DISCLAIMER:</H2> One should note that bi-directional arrows used in all the graphs are NOT an indication of node directions: in our code, they are used to plot un-directed edges."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Database 1 - SGS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variables: 0 1\n",
      "Conditional set: []\n",
      "Variables: 0 2\n",
      "Conditional set: [1, 3, 4]\n",
      "Variables: 0 4\n",
      "Conditional set: [1, 2, 3]\n",
      "Variables: 1 2\n",
      "Conditional set: [3, 4]\n",
      "Variables: 1 4\n",
      "Conditional set: [0, 2, 3]\n",
      "Variables: 2 4\n",
      "Conditional set: [0, 1, 3]\n"
     ]
    }
   ],
   "source": [
    "#Set of separating sets for non-adjacent pairs of variables\n",
    "graph_nodes = list(range(D1.shape[1]))\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(graph_nodes)\n",
    "ci_number = 0\n",
    "extracted_Z = []\n",
    "checked_nodes = []\n",
    "    \n",
    "for X in graph_nodes:\n",
    "    for Y in graph_nodes:\n",
    "        if X == Y: continue\n",
    "        elif [X, Y] in checked_nodes: continue\n",
    "        else:\n",
    "            V = list(range(D1.shape[1]))\n",
    "            del V[V.index(X)]\n",
    "            del V[V.index(Y)]\n",
    "\n",
    "            ci_res = False\n",
    "\n",
    "            for Z in sorted(create_combinations(V), reverse = True):\n",
    "                ci_res = ci_test(D1, X, Y, list(Z))\n",
    "                ci_number += 1\n",
    "                checked_nodes.append([X, Y])\n",
    "                checked_nodes.append([Y, X])\n",
    "                if ci_res == True:\n",
    "                    extracted_Z.append([X, Y, list(Z)])\n",
    "                    print(\"Variables:\", X, Y)\n",
    "                    print(\"Conditional set:\", list(Z))\n",
    "                    break\n",
    "\n",
    "            if ci_res == False:\n",
    "                G.add_edge(X,Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Database 4 - PC2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Database #$ - PC2 algorithm\n",
    "PC2_M4, PC2_M4_Z, PC2_M4_t = PC2_new(D4)\n",
    "PC2_M4 = rulmk2(rulmk1(retrieve_v_shape(PC2_M4, PC2_M4_Z)))\n",
    "PC2_G4 = nx.from_numpy_matrix(PC2_M4, create_using = nx.DiGraph())\n",
    "title_PC2_G4 = \"Causal structure of dataset #4 using PC2 algorithm\\n\" + \"N of tests performed:\" + str(PC2_M4_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Causal structure of dataset #4 using PC2 algorithm\n",
      "N of tests performed:49698\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(title_PC2_G4)\n",
    "nx.draw_circular(PC2_G4,  with_labels=True, node_color='orange', node_size=400, edge_color='black', linewidths=1, font_size=12)              \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "PC2_M4_export = np.matrix(PC2_M4)\n",
    "np.savetxt('PC2_G4.csv',PC2_M4_export, delimiter=',', fmt='%10f')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9l4orY-G1g6C"
   },
   "source": [
    "## Exercise #2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_YZ1(X, Y, Z, N, t): \n",
    "    # Fill the columns of YZ1 with certain values contained in the different nodes\n",
    "    YZ1 = np.zeros((N, t + 10*(t - 1)) )\n",
    "    YZ1[:, :t] = Y[:, :t] \n",
    "    for i in range(10):\n",
    "        YZ1[:, t + i * (t - 1): t + (i+1) * (t - 1)] = Z[i][:, :(t - 1)]\n",
    "\n",
    "    return YZ1.T\n",
    "     \n",
    "def compute_XYZ1(X, Y, Z, N, t): \n",
    "    # Fill the columns of XYZ1 with certain values contained in the different nodes\n",
    "    XYZ1 = np.zeros((N, 12 * (t - 1)))\n",
    "    XYZ1[:, :(t - 1)] = X[:, :(t - 1)] \n",
    "    XYZ1[:, (t - 1):(2 * (t - 1))] = Y[:, :(t - 1)]\n",
    "    for i in range(10):\n",
    "        XYZ1[:, ((i+2) * (t - 1)): (i+3) * (t - 1)] = Z[i][:, :(t - 1)]\n",
    "\n",
    "    return XYZ1.T\n",
    "    \n",
    "def compute_YZ2(X, Y, Z, N, t): \n",
    "    # Fill the columns of YZ2 with certain values contained in the different nodes\n",
    "    YZ2 = np.zeros((N, 11 * (t - 1))) \n",
    "    YZ2[:, :(t - 1)] = Y[:, :(t - 1)] \n",
    "    for i in range(10):\n",
    "        YZ2[:, ((i+1) * (t - 1)): (i+2) * (t - 1)] = Z[i][:, :(t - 1)]\n",
    "\n",
    "    return YZ2.T\n",
    "    \n",
    "\n",
    "def compute_XYZ2(X, Y, Z, N, t): \n",
    "    # Fill the columns of XYZ2 with certain values contained in the different nodes\n",
    "    XYZ2 = np.zeros((N, t + 11 * (t - 1)))\n",
    "    XYZ2[:, :(t - 1)] = X[:, :(t - 1)] \n",
    "    XYZ2[:, (t - 1):(2*t - 1)] = Y[:, :t]\n",
    "    for i in range(10):\n",
    "        XYZ2[:, t + (i+1) * (t - 1): t + (i+2) * (t - 1)] = Z[i][:, :(t - 1)]\n",
    "\n",
    "    return XYZ2.T\n",
    "\n",
    "def find_link(i, j, df_market, threshold):\n",
    "    '''\n",
    "    Calculate the DI of:\n",
    "    - i --> First company taken into account \n",
    "    - j --> Second company taken into account \n",
    "    with respect to the other nodes\n",
    "    '''\n",
    "    X = df_market[i]\n",
    "    Y = df_market[j]\n",
    "    Z = np.zeros((10, 190, 7))\n",
    "    N,T = np.shape(X)\n",
    "    c = 0\n",
    "    DI = 0\n",
    "    \n",
    "    # Compute the concatenation of the other nodes in order to get Z\n",
    "    for k in range(n):\n",
    "        if k != i and k != j:\n",
    "            Z[c] = df_market[k]\n",
    "            c += 1\n",
    "\n",
    "    for t in range(2, T + 1):\n",
    "        # Compute YZ1 \n",
    "        YZ1 = compute_YZ1(X, Y, Z, N, t)\n",
    "        # Compute XYZ1\n",
    "        XYZ1 = compute_XYZ1(X, Y, Z, N, t)\n",
    "        # Compute YZ2\n",
    "        YZ2 = compute_YZ2(X, Y, Z, N, t)\n",
    "        # Compute XYZ2\n",
    "        XYZ2 = compute_XYZ2(X, Y, Z, N, t)\n",
    "        \n",
    "        #Put everything together\n",
    "        DI = DI + 1/2 * np.log(np.linalg.det(np.cov(YZ1))/np.linalg.det(np.cov(YZ2)) * np.linalg.det(np.cov(XYZ1)) / (np.linalg.det(np.cov(XYZ2))))\n",
    "    \n",
    "    # Check if DI is positive or negative \n",
    "    if DI < threshold:\n",
    "        return False, DI\n",
    "    return True, DI \n",
    "        \n",
    "def n_size_edges(nodes,edges):\n",
    "    size = np.zeros(len(nodes))\n",
    "    for n in nodes:\n",
    "        for k in edges:\n",
    "            if n in k:\n",
    "                size[n] = size[n]+1      \n",
    "    return size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load the data\n",
    "df_market = scipy.io.loadmat('data/market.mat')['DI'].T\n",
    "n = len(df_market)\n",
    "# Initialize the nodes and the edges (which are unknown = empty in the beginning)\n",
    "node = np.arange(n) \n",
    "edges = []\n",
    "\n",
    "DI_matrix1 = []\n",
    "# For each node we check if there is a link with any other node\n",
    "for i in range(n):\n",
    "    DI_row = []\n",
    "    for j in range(n):\n",
    "        if i != j:\n",
    "            \n",
    "            # If a link is found, we add it as an edge between i and j\n",
    "            link_bool, link_value = find_link(i, j, df_market, 0.5)\n",
    "            DI_row.append(link_value)\n",
    "            if link_bool == True: \n",
    "                edges.append([i, j])\n",
    "        if i == j:\n",
    "            DI_row.append(0)\n",
    "    DI_matrix1.append(DI_row)\n",
    "                \n",
    "size = n_size_edges(node, edges)\n",
    "\n",
    "G2_1 =  nx.DiGraph()\n",
    "for index in range(len(node)):\n",
    "        G2_1.add_node(node[index], nodesize = size[index])\n",
    "for index in edges:\n",
    "    G2_1.add_edge(index[0], index[1])\n",
    "\n",
    "# Plot the graph\n",
    "my_pos = nx.spring_layout(G2_1, seed = 37)\n",
    "nx.draw(G2_1, pos = my_pos, with_labels =True, node_color ='orange', node_size =400, edge_color='black', linewidths =1, font_size =15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 0. 1. 1. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "EX2_M1 = nx.to_numpy_matrix(G2_1)\n",
    "print(EX2_M1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "DI_matrix1 = np.matrix(DI_matrix1)\n",
    "np.savetxt('DI_matrix1.csv',DI_matrix1, delimiter=',', fmt='%10f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_tree(df_market, threshold):\n",
    "    n = len(df_market)\n",
    "    # Initialize the nodes and the edges (which are unknown = empty in the beginning)\n",
    "    node = [] \n",
    "    edges = []\n",
    "    DI_matrix2 = []\n",
    "    # For each node we check if there is a link with any other node\n",
    "    for i in range(n): \n",
    "        DI_row = []\n",
    "        for j in range(n):\n",
    "            if i != j:\n",
    "                # If a link is found, we add it as an edge between i and j.\n",
    "                link_bool, link_value = find_link(i, j, df_market, threshold)\n",
    "                DI_row.append(link_value)\n",
    "                if link_bool == True: \n",
    "                    edges.append([i, j])\n",
    "                    # If a node is not already discover it is now \n",
    "                    if i not in node:   \n",
    "                        node.append(i)\n",
    "                    if j not in node:\n",
    "                        node.append(j)\n",
    "            if i == j:\n",
    "                DI_row.append(0)\n",
    "        DI_matrix2.append(DI_row)\n",
    "                \n",
    "    return node, edges, DI_matrix2\n",
    "\n",
    "\n",
    "\n",
    "def find_ground(threshold_max, threshold_min, iterations, df_market):\n",
    "    # To be sure to link the 12 nodes\n",
    "    for n in range(iterations):\n",
    "        \n",
    "        \n",
    "        threshold_new = (threshold_max + threshold_min)/2\n",
    "        \n",
    "        node,_,DI_matrix2  = compute_tree(df_market, threshold_new)\n",
    "        \n",
    "        # If all the nodes are linked together\n",
    "        if len(node) == 12:\n",
    "            threshold_min = threshold_new\n",
    "        # If at least one node is not linked with all the other nodes\n",
    "        elif len(node) < 12:\n",
    "            threshold_max = threshold_new            \n",
    "    return threshold_min, DI_matrix2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A feasible threshold is 0.38153419677443867\n"
     ]
    }
   ],
   "source": [
    "threshold_max = 0.75\n",
    "threshold_min = 0.25\n",
    "iterations = 100\n",
    "final_threshold, DI_matrix2 = find_ground(threshold_max, threshold_min, iterations, df_market)\n",
    "print(\"A feasible threshold is\", final_threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "node, edges, DI_matrix2 = compute_tree(df_market, final_threshold)\n",
    "size = n_size_edges(node, edges)\n",
    "G2_2 =  nx.DiGraph()\n",
    "for index in range(len(node)):\n",
    "        G2_2.add_node(node[index], nodesize = size[index])\n",
    "for index in edges:\n",
    "    G2_2.add_edge(index[0], index[1])\n",
    "    \n",
    "# Plot the graph\n",
    "my_pos = nx.spring_layout(G2_2, seed = 1)\n",
    "nx.draw(G2_2, pos = my_pos, with_labels =True, node_color ='orange', node_size =400, edge_color='black', linewidths =1, font_size =15, k=0.15, iterations=20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 1 1 1 1 1 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 1 0 0 0 0 0]\n",
      " [0 0 0 0 1 0 1 1 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [1 1 0 0 0 0 0 1 0 0 1 1]\n",
      " [1 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 1 0 0 1 1 1 0 0]\n",
      " [0 0 0 0 0 0 0 0 1 0 0 0]\n",
      " [0 0 0 0 0 1 0 0 0 0 0 0]\n",
      " [0 1 0 0 1 0 1 1 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "EX2_M2 = nx.adjacency_matrix(G2_2)\n",
    "print(EX2_M2.todense())"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "CI Project.ipynb",
   "provenance": []
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}