1-observations.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "from pathlib import Path\n",
    "import networkx as nx\n",
    "from tqdm.notebook import tqdm, trange\n",
    "import pickle\n",
    "\n",
    "markers = ['o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd', 'P', 'X']\n",
    "colors = [\n",
    "    '#377eb8',\n",
    "    '#e41a1c',\n",
    "    '#4daf4a',\n",
    "    '#984ea3',\n",
    "    '#ff7f00',\n",
    "    '#ffff33',\n",
    "    '#a65628',\n",
    "    '#f781bf',\n",
    "    '#999999',\n",
    "]\n",
    "\n",
    "graph_names = [\n",
    "    # social\n",
    "    'OF',\n",
    "    'openflights',\n",
    "    # hypergraphs\n",
    "    'coauth-DBLP-proj-graph',\n",
    "    'coauth-MAG-Geology-proj-graph',\n",
    "    'threads-ask-ubuntu-proj-graph',\n",
    "    'threads-math-sx-proj-graph',\n",
    "    'threads-stack-overflow-proj-graph',\n",
    "    # temporal\n",
    "    'sx-askubuntu',\n",
    "    'sx-mathoverflow',\n",
    "    'sx-stackoverflow',\n",
    "    'sx-superuser',\n",
    "]\n",
    "\n",
    "graph_names_short = [\n",
    "    # social\n",
    "    'OF',\n",
    "    'FL',\n",
    "    # hypergraphs\n",
    "    'co-DB',\n",
    "    'co-GE',\n",
    "    'th-UB',\n",
    "    'th-MA',\n",
    "    'th-SO',\n",
    "    # temporal\n",
    "    'sx-UB',\n",
    "    'sx-MA',\n",
    "    'sx-SO',\n",
    "    'sx-SU',\n",
    "]\n",
    "\n",
    "name2nameShort = dict(zip(graph_names, graph_names_short))\n",
    "\n",
    "g2fitting = {\n",
    "    # social\n",
    "    'OF': 1,\n",
    "    'openflights': 2,\n",
    "    # hypergraphs\n",
    "    'coauth-DBLP-proj-graph': 3,\n",
    "    'coauth-MAG-Geology-proj-graph': 3,\n",
    "    'threads-ask-ubuntu-proj-graph': 1,\n",
    "    'threads-math-sx-proj-graph': 1,\n",
    "    'threads-stack-overflow-proj-graph': 1,\n",
    "    # temporal\n",
    "    'sx-askubuntu': 2,\n",
    "    'sx-mathoverflow': 2,\n",
    "    'sx-stackoverflow': 2,\n",
    "    'sx-superuser': 2,\n",
    "}\n",
    "\n",
    "g2nm = {\n",
    "    'OF': (897, 71380),\n",
    "    'openflights': (2905, 15645),\n",
    "\n",
    "    'coauth-DBLP-proj-graph': (1654109, 7713116),\n",
    "    'coauth-MAG-Geology-proj-graph': (898648, 4891112),\n",
    "    'threads-ask-ubuntu-proj-graph': (82075, 182648),\n",
    "    'threads-math-sx-proj-graph': (152702, 1088735),\n",
    "    'threads-stack-overflow-proj-graph': (2301070, 20989078),\n",
    "\n",
    "    'sx-askubuntu': (152599, 453221),\n",
    "    'sx-mathoverflow': (24668, 187939),\n",
    "    'sx-stackoverflow': (2572345, 28177464),\n",
    "    'sx-superuser': (189191, 712870),\n",
    "}\n",
    "\n",
    "gt_c_star_wt1 = {\n",
    "    'OF': 241,\n",
    "    'openflights': 64,\n",
    "\n",
    "    'coauth-DBLP-proj-graph': 83,\n",
    "    'coauth-MAG-Geology-proj-graph': 74,\n",
    "    'threads-ask-ubuntu-proj-graph': 73,\n",
    "    'threads-math-sx-proj-graph': 372,\n",
    "    'threads-stack-overflow-proj-graph': 685,\n",
    "\n",
    "    'sx-askubuntu': 152,\n",
    "    'sx-mathoverflow': 185,\n",
    "    'sx-stackoverflow': 886,\n",
    "    'sx-superuser': 202,\n",
    "}\n",
    "\n",
    "gt_c_star_more = {\n",
    "    'OF': [(241, 271), (190, 192), (157, 156), (134, 137), (119, 101)],\n",
    "    'openflights': [(64, 66), (31, 31), (17, 17), (None, None), (None, None)],\n",
    "    'coauth-DBLP-proj-graph': [(83, 88), (36, 29), (22, 24), (20, 21), (16, 16)],\n",
    "    'coauth-MAG-Geology-proj-graph': [(74, 92), (52, 49), (34, 40), (28, 30), (24, 21)],\n",
    "    'threads-ask-ubuntu-proj-graph': [(73, 87), (30, 31), (19, 20), (18, 11), (15, 11)],\n",
    "    'threads-math-sx-proj-graph': [(372, 401), (145, 153), (114, 114), (84, 67), (63, 59)],\n",
    "    'threads-stack-overflow-proj-graph': [(685, 750), (208, 205), (134, 129), (97, 82), (74, 72)],\n",
    "    'sx-askubuntu': [(152, 149), (63, 69), (48, 42), (36, 27), (31, 22)],\n",
    "    'sx-mathoverflow': [(185, 181), (113, 102), (75, 63), (60, 49), (51, 41)],\n",
    "    'sx-stackoverflow': [(886, 749), (407, 324), (221, 203), (169, 130), (120, 103)],\n",
    "    'sx-superuser': [(202, 206), (96, 93), (63, 54), (48, 37), (36, 27)],\n",
    "}\n",
    "\n",
    "p_data = Path(f'data')\n",
    "p_data.mkdir(exist_ok=True)\n",
    "\n",
    "p_results = Path('results')\n",
    "p_results.mkdir(exist_ok=True)\n",
    "\n",
    "Edge = tuple[int, int]\n",
    "EdgeAndWeight = tuple[int, int, int]\n",
    "graphs_sorted_m = sorted(graph_names, key=lambda xx: g2nm[xx][1])\n",
    "\n",
    "\n",
    "def iter_edges(input_graph, with_weight=False, desc='edges'):\n",
    "    return tqdm(input_graph.edges.data('weight', default=1) if with_weight else input_graph.edges,\n",
    "                total=input_graph.number_of_edges(), leave=False, desc=desc)\n",
    "\n",
    "\n",
    "def iter_nodes(input_graph, desc='nodes'):\n",
    "    return tqdm(input_graph.nodes, total=input_graph.number_of_nodes(), leave=False, desc=desc)\n",
    "\n",
    "\n",
    "def data_exist(ds, data_name_, layer_index=None):\n",
    "    if layer_index is not None:\n",
    "        return (p_data / data_name_ / f'{ds}.{data_name_}_layer{layer_index}').is_file()\n",
    "    return (p_data / data_name_ / f'{ds}.{data_name_}').is_file()\n",
    "\n",
    "\n",
    "def data_file_path(ds, data_name_, layer_index=None, write=False):\n",
    "    if write:\n",
    "        (p_data / data_name_).mkdir(exist_ok=True)\n",
    "        mode = 'wb'\n",
    "    else:\n",
    "        mode = 'rb'\n",
    "    if layer_index is not None:\n",
    "        return p_data / data_name_ / f'{ds}.{data_name_}_layer{layer_index}', mode\n",
    "    return p_data / data_name_ / f'{ds}.{data_name_}', mode\n",
    "\n",
    "\n",
    "def save_data(data, ds, data_name_, layer_index=None):\n",
    "    with open(*data_file_path(ds, data_name_, write=True, layer_index=layer_index)) as f_:\n",
    "        pickle.dump(data, f_)\n",
    "\n",
    "\n",
    "def load_data(ds, data_name_, layer_index=None):\n",
    "    with open(*data_file_path(ds, data_name_, write=False, layer_index=layer_index)) as f_:\n",
    "        return pickle.load(f_)\n",
    "\n",
    "\n",
    "def min_max_tuple(xx, yy):\n",
    "    return min(xx, yy), max(xx, yy)\n",
    "\n",
    "\n",
    "def reorder_nodes(input_graph):\n",
    "    return nx.convert_node_labels_to_integers(input_graph)\n",
    "\n",
    "\n",
    "def take_gcc(input_graph):\n",
    "    return input_graph.subgraph(max(nx.connected_components(input_graph), key=len))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from scipy.stats import pearsonr\n",
    "\n",
    "# Why the number of common neighbors?\n",
    "metrics = [\n",
    "    'CN',\n",
    "    'SA',\n",
    "    'JC',\n",
    "    'HP',\n",
    "    'HD',\n",
    "    'SI',\n",
    "    'LI',\n",
    "    'AA',\n",
    "    'RA',\n",
    "    'PA',\n",
    "    'FM',\n",
    "    'DL',\n",
    "    'EC',\n",
    "    'LP',\n",
    "]\n",
    "for graph_name in graphs_sorted_m:\n",
    "    print(graph_name)\n",
    "    graph_name_short = name2nameShort[graph_name]\n",
    "    weights = load_data(graph_name, 'weights')\n",
    "    y = repeat_list = [int(w > 1) for w in weights]\n",
    "    m2pearsonResults = dict()\n",
    "    for metric in metrics:\n",
    "        try:\n",
    "            x = metric_list = load_data(graph_name, f'{metric}-list')\n",
    "            r, p = pearsonr(x, y)\n",
    "            m2pearsonResults[metric] = (r, p)\n",
    "            print(graph_name_short, metric, f'Pearson\\'s r = {r}')\n",
    "        except:\n",
    "            continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import numpy as np\n",
    "from scipy.stats import pearsonr\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# observation 1: adjacency and strongness\n",
    "\n",
    "p_results_obs = p_results / 'obs1-adjacency_and_strongness'\n",
    "p_results_obs.mkdir(exist_ok=True)\n",
    "\n",
    "plt.rcParams.update({'font.size': 30})\n",
    "\n",
    "g2ax = dict()\n",
    "for graph_name in graphs_sorted_m:\n",
    "    graph_name_short = name2nameShort[graph_name]\n",
    "    fig, axes = plt.subplots(1, 5, figsize=(28, 4), constrained_layout=True)\n",
    "    for i_layer in range(1, 6):\n",
    "        if i_layer > 1:\n",
    "            cn2p = load_data(graph_name, 'numberOfCN2numberOfPairs_layers', layer_index=i_layer)\n",
    "            G_i = load_data(graph_name, 'layers', layer_index=i_layer)\n",
    "            cn2W = defaultdict(list)\n",
    "            v2Nv_i = {v: set(G_i[v]) for v in iter_nodes(G_i)}\n",
    "            cn2m = defaultdict(int)\n",
    "            cn2M = defaultdict(int)\n",
    "            for u, v, w in iter_edges(G_i, with_weight=True):\n",
    "                Nu, Nv = v2Nv_i[u], v2Nv_i[v]\n",
    "                cn_uv = len(Nu & Nv)\n",
    "                cn2W[cn_uv].append(w)\n",
    "                cn2m[cn_uv] += 1\n",
    "                if w > i_layer:\n",
    "                    cn2M[cn_uv] += 1\n",
    "            save_data(dict(cn2W), graph_name, 'numberOfCN2weightList_layers', layer_index=i_layer)\n",
    "        else:  # i = 1; the original graph\n",
    "            cn2p = load_data(graph_name, 'numberOfCN2numberOfPairs')\n",
    "            number_of_CNs_list = load_data(graph_name, 'number_of_CNs_list')\n",
    "            weights = load_data(graph_name, 'weights')\n",
    "            cn2W = defaultdict(list)\n",
    "            cn2m = defaultdict(int)\n",
    "            cn2M = defaultdict(int)\n",
    "            for cn, w in zip(number_of_CNs_list, weights):\n",
    "                cn2W[cn].append(w)\n",
    "                cn2m[cn] += 1\n",
    "                if w > i_layer:\n",
    "                    cn2M[cn] += 1\n",
    "            save_data(dict(cn2W), graph_name, 'numberOfCN2weightList')\n",
    "        numOfCN_pair_list = sorted(cn2p)\n",
    "        numOfCN_edge_list = [c for c in numOfCN_pair_list if cn2m[c] >= 1]\n",
    "        p_array = np.array([cn2p[cn] for cn in numOfCN_edge_list])\n",
    "        m_array = np.array([cn2m[cn] for cn in numOfCN_edge_list])\n",
    "        M_array = np.array([cn2M[cn] for cn in numOfCN_edge_list])\n",
    "\n",
    "        p_con_array = m_array / p_array\n",
    "        p_str_array = M_array / m_array\n",
    "\n",
    "        X = numOfCN_edge_list\n",
    "        Y_con = p_con_array\n",
    "        Y_str = p_str_array\n",
    "        r, _ = pearsonr(Y_con, Y_str)\n",
    "\n",
    "        axes[i_layer - 1].scatter(X, Y_con * 100, label='adjacent', alpha=0.5)\n",
    "        axes[i_layer - 1].scatter(X, Y_str * 100, label='strong', alpha=0.5)\n",
    "        lgd_wt = axes[i_layer - 1].legend(loc='lower right',\n",
    "                                          # bbox_to_anchor=(1.0, 0.5),\n",
    "                                          # fontsize=20,\n",
    "                                          markerscale=2,\n",
    "                                          borderpad=0.05,\n",
    "                                          labelspacing=0.2,\n",
    "                                          handlelength=0.5,\n",
    "                                          handletextpad=0.2,\n",
    "                                          borderaxespad=0.2)\n",
    "        for lh in lgd_wt.legendHandles:\n",
    "            lh.set_alpha(1)\n",
    "\n",
    "        xLabel = '# common neighbors'\n",
    "        yLabel = '% of adj. pairs\\nor strong edges'\n",
    "        axes[i_layer - 1].set_xlabel(xLabel)\n",
    "        axes[i_layer - 1].set_ylabel(yLabel)\n",
    "        axes[i_layer - 1].set_yticks([0, 50, 100])\n",
    "        max_x_tick = ((max(numOfCN_pair_list) * 0.95) // 10) * 10\n",
    "        axes[i_layer - 1].set_xticks([0, max_x_tick // 2, max_x_tick])\n",
    "        axes[i_layer - 1].set_title(f'{graph_name_short}\\nlayer-{i_layer}, r = {r:.3f}', fontsize=30)\n",
    "    plt.savefig(p_results_obs / f'{graph_name}.png', bbox_inches='tight')\n",
    "    plt.savefig(p_results_obs / f'{graph_name}.pdf', bbox_inches='tight')\n",
    "    plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "from pathlib import Path\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# observation 2: the fractions of strong edges\n",
    "p_results_obs = p_results / 'obs2-FoSEs'\n",
    "p_results_obs.mkdir(exist_ok=True)\n",
    "\n",
    "plt.rcParams.update({'font.size': 28})\n",
    "xLabel = '# common neighbors'\n",
    "yLabel = '% of strong edges'\n",
    "\n",
    "for graph_name in graphs_sorted_m:\n",
    "    print(graph_name)\n",
    "    graph_name_short = name2nameShort[graph_name]\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=5, figsize=(28, 4), constrained_layout=True)\n",
    "    for i_layer in trange(1, 6):\n",
    "        if i_layer > 1:\n",
    "            cn2W = load_data(graph_name, 'numberOfCN2weightList_layers', layer_index=i_layer)\n",
    "        else:\n",
    "            cn2W = load_data(graph_name, 'numberOfCN2weightList')\n",
    "        numOfCN_array = np.array(sorted(cn2W))\n",
    "        numOfEdges_array = np.array([len(cn2W[c]) for c in numOfCN_array])\n",
    "        m_total = sum(numOfEdges_array)\n",
    "        numOfSEs_array = np.array([sum(w > i_layer for w in cn2W[c]) for c in numOfCN_array])\n",
    "        fracOfSEs_array = numOfSEs_array / numOfEdges_array\n",
    "\n",
    "        i_range = [gt_c_star_more[graph_name][i_layer - 1][1]]\n",
    "        for i in tqdm(i_range):\n",
    "            X = numOfCN_array[:i].reshape(-1, 1)\n",
    "            y = fracOfSEs_array[:i]\n",
    "            reg = LinearRegression().fit(X, y)\n",
    "            R2 = reg.score(X, y)\n",
    "            slope = reg.coef_[0]\n",
    "            intercept = reg.intercept_\n",
    "            y_pred = reg.predict(X)\n",
    "\n",
    "            ax[i_layer - 1].scatter(numOfCN_array, fracOfSEs_array * 100, alpha=0.5, label='GT')\n",
    "            ax[i_layer - 1].plot(X.flatten(), y_pred * 100, label='linear fitting', color='r', linewidth=3)\n",
    "            lgd_wt = ax[i_layer - 1].legend(loc='lower right',\n",
    "                                            # bbox_to_anchor=(1.0, 0.5),\n",
    "                                            # fontsize=20,\n",
    "                                            markerscale=2,\n",
    "                                            borderpad=0.05,\n",
    "                                            labelspacing=0.2,\n",
    "                                            handlelength=0.5,\n",
    "                                            handletextpad=0.2,\n",
    "                                            borderaxespad=0.2)\n",
    "            for lh in lgd_wt.legendHandles:\n",
    "                lh.set_alpha(1)\n",
    "            ax[i_layer - 1].set_xlabel(xLabel)\n",
    "            ax[i_layer - 1].set_ylabel(yLabel)\n",
    "\n",
    "            ax[i_layer - 1].set_title(f'{graph_name_short}, layer-{i_layer}\\n' + r'$R^2$ ' + f'= {R2:.3f}', fontsize=28)\n",
    "\n",
    "            max_x_tick = ((max(numOfCN_array) * 0.95) // 10) * 10\n",
    "            ax[i_layer - 1].set_xticks([0, max_x_tick // 2, max_x_tick])\n",
    "            min_y_tick = ((math.ceil(min(fracOfSEs_array) * 100) // 10) + 1) * 10\n",
    "            ax[i_layer - 1].set_yticks([min_y_tick, (min_y_tick + 100) // 2, 100])\n",
    "    plt.savefig(p_results_obs / f'{graph_name}.png', bbox_inches='tight')\n",
    "    plt.savefig(p_results_obs / f'{graph_name}.pdf', bbox_inches='tight')\n",
    "    plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "from pathlib import Path\n",
    "import networkx\n",
    "import numpy as np\n",
    "from collections import defaultdict, Counter\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "from scipy.stats import linregress\n",
    "from matplotlib.ticker import StrMethodFormatter\n",
    "\n",
    "# observation 3: a power law across layers\n",
    "p_results_obs = p_results / 'obs3-power-law'\n",
    "p_results_obs.mkdir(exist_ok=True)\n",
    "\n",
    "plt.rcParams.update({'font.size': 20})\n",
    "plt.figure()\n",
    "\n",
    "for graph_name in graphs_sorted_m:\n",
    "    print(graph_name)\n",
    "    graph_name_short = name2nameShort[graph_name]\n",
    "    X = []\n",
    "    Y = []\n",
    "    edges_and_weights = load_data(graph_name, 'edges_and_weights')\n",
    "    w2cnt = Counter([w for _, _, w in edges_and_weights])\n",
    "    if graph_name == 'openflights':\n",
    "        i_layer_range = trange(1, 5)\n",
    "    elif graph_name == 'OF':\n",
    "        i_layer_range = trange(2, 12)\n",
    "    else:\n",
    "        i_layer_range = trange(1, 11)\n",
    "    for i_layer in i_layer_range:\n",
    "        if i_layer > 1:\n",
    "            cn2W = load_data(graph_name, 'numberOfCN2weightList_layers', layer_index=i_layer)\n",
    "        else:\n",
    "            cn2W = load_data(graph_name, 'numberOfCN2weightList')\n",
    "        weights_CN0 = cn2W[0]\n",
    "        m0 = len(weights_CN0)\n",
    "        M0 = sum(w > i_layer for w in weights_CN0)\n",
    "        m_wt = sum(cnt_w for w, cnt_w in w2cnt.items() if w >= i_layer)\n",
    "        M_wt = m_wt - w2cnt[i_layer]\n",
    "        proStrong_total = M_wt / m_wt\n",
    "        proStrong_CN0 = M0 / m0\n",
    "        X, Y = list(X), list(Y)\n",
    "        X.append(proStrong_total)\n",
    "        Y.append(proStrong_CN0)\n",
    "    for ii, (x, y) in enumerate(zip(X, Y)):\n",
    "        plt.scatter(x, y, marker=markers[ii % 7], label=f'{ii + 2}' if graph_name == 'OF' else f'{ii + 1}', s=200)\n",
    "    X, Y = np.array(X), np.array(Y)\n",
    "    # log-log linear regression\n",
    "    linreg = linregress(np.log(X), np.log(Y))\n",
    "    R2 = linreg.rvalue ** 2\n",
    "    plt.plot(X, np.exp(linreg.intercept + linreg.slope * np.log(X)), 'r')\n",
    "    plt.title(f'{graph_name_short}\\n'\n",
    "              f'log(Y) = {linreg.intercept:.3f} + {linreg.slope:.3f} * log(X)\\n$R^2$ = {R2:.2f}')\n",
    "    plt.xlabel('frac. of strong edges among all edges')\n",
    "    plt.ylabel('frac. of strong edges\\namong edges w/o\\ncommon neighbors')\n",
    "    plt.xscale('log')\n",
    "    plt.yscale('log')\n",
    "    if graph_name_short == 'OF':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.75, 0.822, 0.9]\n",
    "        y_list = [0.5, 0.67, 0.898]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'FL':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.3, 0.342, 0.39]\n",
    "        y_list = [0.14, 0.182, 0.237]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'co-DB':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.32, 0.48, 0.72]\n",
    "        y_list = [0.16, 0.32, 0.72]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'co-GE':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.24, 0.36, 0.54, 0.81]\n",
    "        y_list = [0.12, 0.3, 0.75]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'th-UB':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.036, 0.144, 0.576]\n",
    "        y_list = [0.002, 0.032, 0.512]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'th-MA':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.16, 0.32, 0.64]\n",
    "        y_list = [0.01, 0.04, 0.16, 0.64]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'th-SO':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.05, 0.22, 0.968]\n",
    "        y_list = [0.01, 0.095, 0.903]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'sx-UB':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.3, 0.48, 0.768]\n",
    "        y_list = [0.2, 0.36, 0.648]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'sx-MA':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.4, 0.56, 0.784]\n",
    "        y_list = [0.2, 0.36, 0.648]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'sx-SO':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.32, 0.48, 0.72]\n",
    "        y_list = [0.32, 0.48, 0.72]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    elif graph_name_short == 'sx-SU':\n",
    "        # plt.sca(ax[ax_i])\n",
    "        x_list = [0.32, 0.48, 0.72]\n",
    "        y_list = [0.24, 0.36, 0.54, 0.81]\n",
    "        plt.xticks(x_list, list(map(lambda x_: str(x_)[1:], x_list)))\n",
    "        plt.yticks(y_list, list(map(lambda x_: str(x_)[1:], y_list)))\n",
    "    plt.minorticks_off()\n",
    "    plt.legend(loc='center left', bbox_to_anchor=(1.05, 0.5), labelspacing=1.0)\n",
    "    plt.savefig(p_results_obs / f'{graph_name}.png', bbox_inches='tight')\n",
    "    plt.savefig(p_results_obs / f'{graph_name}.pdf', bbox_inches='tight')\n",
    "    plt.clf()\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
}