deepgg-model-statistics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import time\n",
    "import collections\n",
    "import itertools\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "import pickle\n",
    "import seaborn as sns\n",
    "from functools import partial\n",
    "\n",
    "from IPython.display import HTML\n",
    "from scipy.stats import entropy\n",
    "from innvariant_dgl.dataset import graph_to_construction_sequence, construction_sequence_to_graph, construction_sequence_evolution\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('deepgg-combined.pkl', 'rb') as read_handle:\n",
    "    C = pickle.load(read_handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "keys = list(C.keys())\n",
    "keys_dfs = [key for key in keys if '_dfs' in key]\n",
    "keys_bfs = [key for key in keys if '_bfs' in key]\n",
    "keys_process = [key for key in keys if '_process' in key]\n",
    "keys_erdos_renyi = [key for key in keys if 'erdos_renyi' in key]\n",
    "keys_barabasi_albert = [key for key in keys if 'barabasi_albert' in key]\n",
    "keys_watts_strogatz = [key for key in keys if 'watts_strogatz' in key]\n",
    "keys_er_and_bfs = [key for key in keys if 'erdos_renyi' in key and '_bfs' in key]\n",
    "keys_er_and_dfs = [key for key in keys if 'erdos_renyi' in key and '_dfs' in key]\n",
    "keys_ba_and_bfs = [key for key in keys if 'barabasi_albert' in key and '_bfs' in key]\n",
    "keys_ba_and_dfs = [key for key in keys if 'barabasi_albert' in key and '_dfs' in key]\n",
    "keys_ws_and_bfs = [key for key in keys if 'watts_strogatz' in key and '_bfs' in key]\n",
    "keys_ws_and_dfs = [key for key in keys if 'watts_strogatz' in key and '_dfs' in key]\n",
    "\n",
    "subsets = {\n",
    "    'Depth-First-Search': keys_dfs,\n",
    "    'Breadth-First-Search': keys_bfs,\n",
    "    'Construction Process': keys_process,\n",
    "    'Erdos-Renyi model': keys_erdos_renyi,\n",
    "    'Barabasi-Albert model': keys_barabasi_albert,\n",
    "    'Watts-Strogatz model': keys_watts_strogatz,\n",
    "    'Erdos-Renyi + BFS': keys_er_and_bfs,\n",
    "    'Erdos-Renyi + DFS': keys_er_and_dfs,\n",
    "    'Barabasi-Albert + BFS': keys_ba_and_bfs,\n",
    "    'Barabasi-Albert + DFS': keys_ba_and_dfs,\n",
    "    'Watts-Strogatz + BFS': keys_ws_and_bfs,\n",
    "    'Watts-Strogatz + DFS': keys_ws_and_dfs,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of instances:  69\n",
      "Depth-First-Search has 39 instances\n",
      "Breadth-First-Search has 24 instances\n",
      "Construction Process has 6 instances\n",
      "Erdos-Renyi model has 24 instances\n",
      "Barabasi-Albert model has 26 instances\n",
      "Watts-Strogatz model has 19 instances\n",
      "Erdos-Renyi + BFS has 13 instances\n",
      "Erdos-Renyi + DFS has 11 instances\n",
      "Barabasi-Albert + BFS has 4 instances\n",
      "Barabasi-Albert + DFS has 16 instances\n",
      "Watts-Strogatz + BFS has 7 instances\n",
      "Watts-Strogatz + DFS has 12 instances\n"
     ]
    }
   ],
   "source": [
    "print('Total number of instances: ', len(keys))\n",
    "for subset_name in subsets:\n",
    "    print('{name} has {num} instances'.format(name=subset_name, num=len(subsets[subset_name])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'param_train_epochs': 8,\n",
       " 'param_learning_rate': 0.0001,\n",
       " 'param_deepgg_prop_rounds': 2,\n",
       " 'param_deepgg_v_max': 150,\n",
       " 'param_deepgg_node_hidden_size': 16,\n",
       " 'param_deepgg_generate_size': 200,\n",
       " 'param_deepgg_generate_v_min': 0,\n",
       " 'param_dataset_size': 1000,\n",
       " 'param_model_num_v': 50,\n",
       " 'param_model_num_v_min': 50,\n",
       " 'param_model_num_v_max': 50,\n",
       " 'param_model_er_p': 0.2,\n",
       " 'param_model_ws_k': 10,\n",
       " 'param_model_ws_p': 0.2,\n",
       " 'param_model_ba_m': 3,\n",
       " 'param_selected_model': 'generate_seqs_watts_strogatz_dfs',\n",
       " 'param_device': 'cuda:7'}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[list(C.keys())[0]]['meta']['params']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.2])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique([C[key]['meta']['params']['param_model_er_p'] for key in keys_erdos_renyi])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ws_k [10]\n",
      "ws_p [0.2]\n"
     ]
    }
   ],
   "source": [
    "print('ws_k', np.unique([C[key]['meta']['params']['param_model_ws_k'] for key in keys_watts_strogatz]))\n",
    "print('ws_p', np.unique([C[key]['meta']['params']['param_model_ws_p'] for key in keys_watts_strogatz]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique([C[key]['meta']['params']['param_model_ba_m'] for key in keys_barabasi_albert])"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}