00-generate-A-compute-hamming-dist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "import fun as f\n",
    "import pickle\n",
    "from collections import Counter\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adjacency Matrix: A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Compute and dump Adjacency matrix for all WS models -fixed N and p - :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_dic = {}\n",
    "fixed_p_ref = [0.05, 0.1, 0.5, 0.9]\n",
    "experiments = [nx.read_gpickle(\"00-Graphs/011220WS-Graphs-fixed-p-005.json\"),\n",
    "               nx.read_gpickle(\"00-Graphs/011220WS-Graphs-fixed-p-01.json\"),\n",
    "               nx.read_gpickle(\"00-Graphs/011220WS-Graphs-fixed-p-05.json\"),\n",
    "               nx.read_gpickle(\"00-Graphs/011220WS-Graphs-fixed-p-09.json\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, experiment in enumerate(experiments):\n",
    "    print(f'Computing Adj matrix of all WS with fixed N = 300 and p = {fixed_p_ref[idx]}')\n",
    "    A_dic[fixed_p_ref[idx]] = f.compute_A_matrix(experiment['models_ref'], \n",
    "                                               experiment['models'])   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '03-A_exp/02122020-A_WS-all.json'\n",
    "with open(path, 'wb') as t:\n",
    "    pickle.dump(A_dic, t) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Compute and dump Adjacency matrix for all WS models -fixed N and k - :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "WS_fixedk10 = nx.read_gpickle(\"00-Graphs/011220WS-Graphs-fixed-k-10.json\")\n",
    "A_dic = f.compute_A_matrix(WS_fixedk10['models_ref'], WS_fixedk10['models'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '03-A_exp/02122020-A-k10.json'\n",
    "with open(path, 'wb') as t:\n",
    "    pickle.dump(A_dic, t) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Compute Adjacency matrix for all ER models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ER_n150 = nx.read_gpickle(\"00-Graphs/011220ER-Graphs-fixed-n-150.json\")\n",
    "A_dic_ER = f.compute_A_matrix(ER_n150['models_ref'], ER_n150['models'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '03-A_exp/02122020-A_ER.json'\n",
    "with open(path, 'wb') as t:\n",
    "    pickle.dump(A_dic_ER, t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hamming Distance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_all = nx.read_gpickle(\"03-A_exp/04122020-A_all_exp.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute and dump Hamming Distance between WS reference models \n",
    "# and rest of WS models for -fixed N and p - :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing Hamming Distfor all WS with fixed N = 300 and p = p005\n",
      "Computing Hamming Distfor all WS with fixed N = 300 and p = p01\n",
      "Computing Hamming Distfor all WS with fixed N = 300 and p = p05\n",
      "Computing Hamming Distfor all WS with fixed N = 300 and p = p09\n"
     ]
    }
   ],
   "source": [
    "Hamming_distance_avg_dic = {}\n",
    "for key, A_dic in A_all.items():\n",
    "    print(f'Computing Hamming Dist for all WS with fixed N = 300 and p = {key}')\n",
    "    Hamming_distance_avg_dic[key] = f.compute_avg_hamming_distance(A_dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '04-hamming-distance-results/04122020-hd-fixedp.json'\n",
    "with open(path, 'wb') as t:\n",
    "    pickle.dump(Hamming_distance_avg_dic, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute and dump Hamming Distance between WS reference models \n",
    "# and rest of WS models for -fixed N and k - :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_fixedk = nx.read_gpickle(\"03-A_exp/02122020-A-k10.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Hamming_distance_avg_dic = f.compute_avg_hamming_distance(A_fixedk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '04-hamming-distance-results/04122020-hd-WS-fixedk.json'\n",
    "with open(path, 'wb') as t:\n",
    "    pickle.dump(Hamming_distance_avg_dic, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute and dump Hamming Distance between ER reference models \n",
    "# and rest of ER models for -fixed N - :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_ER = nx.read_gpickle(\"03-A_exp/02122020-A_ER.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Hamming_distance_avg_dic = f.compute_avg_hamming_distance(A_ER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '04-hamming-distance-results/04122020-hd-ER.json'\n",
    "with open(path, 'wb') as t:\n",
    "    pickle.dump(Hamming_distance_avg_dic, t)"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}