examples/07_utility_estimate_scaling_plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint\n",
    "import json\n",
    "import uuid\n",
    "\n",
    "import random\n",
    "random.seed(17)\n",
    "\n",
    "import numpy as np\n",
    "np.random.seed(17) # fix NumPy random number generator seed\n",
    "\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "import os\n",
    "\n",
    "# add some relative paths so we can import sampling.py module.\n",
    "import sys\n",
    "sys.path.append(\"../\")\n",
    "sys.path.append(\"../src\")\n",
    "sys_path = sys.path\n",
    "\n",
    "import sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scoring function definitions.\n",
    "\n",
    "def is_number(x):\n",
    "    \"\"\"brief utility function we'll call later to filter mixed lists.\"\"\"\n",
    "    return isinstance(x, (int, float))\n",
    "\n",
    "\n",
    "def blended_utility_score(\n",
    "        instance_data: dict, \n",
    "        ranges: dict,\n",
    "        weights: dict,\n",
    "        sense: dict\n",
    "    ) -> float:\n",
    "    \n",
    "    if instance_data[\"metadata\"][\"edge_type\"] == \"ferromagnetic\":\n",
    "        # ferromagnetic has zero utility.\n",
    "        # a polynomial time approximate sampling routine exists.\n",
    "        return 0.0 # ferromagnetic has zero utility.\n",
    "\n",
    "    if instance_data[\"metadata\"][\"number_of_nodes\"] <= 20:\n",
    "        # small instance has zero utility.\n",
    "        # probability distribution can be calculated explicitly.\n",
    "        return 0.0 \n",
    "    \n",
    "    score = 0.0\n",
    "    rescaled_score_weights = 0.0\n",
    "    params = ranges.keys()\n",
    "    for param in params:\n",
    "\n",
    "        x = instance_data[\"metadata\"][param]\n",
    "        if is_number(x):\n",
    "            rescaled_score_weights += weights[param]\n",
    "\n",
    "            x_min = ranges[param][\"min\"]\n",
    "            x_max = ranges[param][\"max\"]\n",
    "            r = x_max - x_min #range\n",
    "            \n",
    "            if sense[param] == \"bigger_is_higher_score\":\n",
    "                normalized_val = (x - x_min)/r\n",
    "            else:\n",
    "                # so we invert the metric as follows:\n",
    "                x_inv = (x_max - x_min) - (x - x_min)\n",
    "                # note that 0 <= x_inv <= r\n",
    "                # as x --> x_max, then this approaches zero (bad score)\n",
    "                # as x --> x_min, then this approaches the range r (good score)\n",
    "                normalized_val = x_inv / r # now between [0,1]\n",
    "\n",
    "\n",
    "        score += weights[param]*normalized_val\n",
    "\n",
    "    # it's possible that some features of the graph are not numerical/not calculated\n",
    "    # due to the size of the system.  In this case, we don't include the scores\n",
    "    # for those metrics, but we don't want to penalize the overall score by leaving it\n",
    "    # as zero, so we rescale.\n",
    "    score /= rescaled_score_weights\n",
    "    return score # higher is better. [worst, best] == [0, 1]\n",
    "\n",
    "def blended_performance_metric_score(\n",
    "        performance_metrics_data: dict, \n",
    "        ranges: dict,\n",
    "        weights: dict,\n",
    "        sense: dict\n",
    "    ) -> float:\n",
    "\n",
    "    if (not performance_metrics_data[\"within_time_limit\"]):\n",
    "        # disqualified due to time limit exceeded.\n",
    "        return 0.0\n",
    "    \n",
    "    if (not performance_metrics_data[\"returned_required_num_samples_k\"]):\n",
    "        # disqualified due to not returning enough samples.\n",
    "        return 0.0 \n",
    "    \n",
    "    score = 0.0\n",
    "    rescaled_score_weights = 0.0\n",
    "    params = ranges.keys()\n",
    "    for param in params:\n",
    "        \n",
    "        x = performance_metrics_data[param]\n",
    "        if is_number(x):\n",
    "            rescaled_score_weights += weights[param]\n",
    "\n",
    "            x_min = ranges[param][\"min\"]\n",
    "            x_max = ranges[param][\"max\"]\n",
    "            r = x_max - x_min # range\n",
    "\n",
    "            if sense[param] == \"bigger_is_higher_score\":\n",
    "                normalized_val = (x - x_min)/r\n",
    "            else:\n",
    "                # so we invert the metric as follows:\n",
    "                x_inv = (x_max - x_min) - (x - x_min)\n",
    "                # note that 0 <= x_inv <= r\n",
    "                # as x --> x_max, then this approaches zero (bad score)\n",
    "                # as x --> x_min, then this approaches the range r (good score)\n",
    "                normalized_val = x_inv / r # now between [0,1]\n",
    "            score += weights[param]*normalized_val\n",
    "\n",
    "        \n",
    "\n",
    "    # it's possible that KL divergence and other metrics are NOT calculated\n",
    "    # due to the size of the system.  In this case, we don't include the scores\n",
    "    # for those metrics, but we don't want to penalize the overall score by leaving it\n",
    "    # as zero, so we rescale.\n",
    "    score /= rescaled_score_weights\n",
    "    return score # higher is better. [worst, best] == [0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of benchmark instances read in: 29\n",
      "number of performance metric files read in: 44\n"
     ]
    }
   ],
   "source": [
    "# Read in data from instances and performance_metric files\n",
    "\n",
    "instances_relative_path = \"../benchmark_instances/\"\n",
    "benchmark_instance_filenames = os.listdir(instances_relative_path)\n",
    "\n",
    "performance_metrics_relative_path = \"../benchmark_proctor_performance_metrics/\"\n",
    "performance_metrics_filenames = os.listdir(performance_metrics_relative_path)\n",
    "\n",
    "perf_metrics_list = []\n",
    "for perf_fname in performance_metrics_filenames:\n",
    "    if \".json\" in perf_fname:\n",
    "        with open(performance_metrics_relative_path + perf_fname,\"rb\") as f:\n",
    "            perf_metrics = json.loads(f.read())\n",
    "            perf_metrics_list.append(perf_metrics)\n",
    "\n",
    "instance_data_list = []        \n",
    "for inst_fname in benchmark_instance_filenames:\n",
    "    if \".json\" in inst_fname:\n",
    "        with open(instances_relative_path + inst_fname,\"rb\") as f:\n",
    "            instance_data = json.loads(f.read())\n",
    "            instance_data_list.append(instance_data)\n",
    "\n",
    "print(\"number of benchmark instances read in:\", len(instance_data_list))\n",
    "print(\"number of performance metric files read in:\", len(perf_metrics_list))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance data ranges\n",
      "{'density': {'max': 1.0, 'min': 0.06060606060606061},\n",
      " 'effective_max_edge_weight_magnitude': {'max': 153.55045757612507,\n",
      "                                         'min': 0.3333333333333333},\n",
      " 'effective_min_edge_weight_magnitude': {'max': 10.0,\n",
      "                                         'min': 0.042806140105660535},\n",
      " 'max_degree': {'max': 39, 'min': 4},\n",
      " 'number_of_edges': {'max': 780, 'min': 18},\n",
      " 'number_of_nodes': {'max': 100, 'min': 9}}\n",
      "\n",
      "\n",
      "performance metrics ranges:\n",
      "{'average_seconds_per_sample': {'max': 0.7683654350000001,\n",
      "                                'min': 0.025053857000000002},\n",
      " 'ell_0_norm': {'max': 5050, 'min': 45},\n",
      " 'ell_1_norm': {'max': 14141.726192702627, 'min': 1.3762265975207353},\n",
      " 'ell_2_norm': {'max': 615.23145641811, 'min': 0.2856436894343884},\n",
      " 'ell_inf_norm': {'max': 151.76955626542434, 'min': 0.11493669374828969},\n",
      " 'kl_divergence': {'max': 6.731482086332532, 'min': 0.2167831368456384},\n",
      " 'total_variation': {'max': 0.21898954174766802, 'min': 0.0009999224302853023}}\n"
     ]
    }
   ],
   "source": [
    "# calculate \"ranges\" (i.e., min, max) for data.  This is later used to normalize scores.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "instance_data_ranges = {}\n",
    "utility_score_params = [\n",
    "    \"number_of_nodes\",\n",
    "    \"number_of_edges\",\n",
    "    \"effective_min_edge_weight_magnitude\",\n",
    "    \"effective_max_edge_weight_magnitude\",\n",
    "    \"density\",\n",
    "    \"max_degree\"\n",
    "]\n",
    "\n",
    "for param in utility_score_params:\n",
    "    tmp = [ d[\"metadata\"][param] for d in instance_data_list]\n",
    "    tmp = list(filter(is_number, tmp))\n",
    "    instance_data_ranges[param] = {}\n",
    "    instance_data_ranges[param][\"min\"] = min(tmp)\n",
    "    instance_data_ranges[param][\"max\"] = max(tmp)\n",
    "\n",
    "print(\"instance data ranges\")\n",
    "pprint.pprint(instance_data_ranges)\n",
    "\n",
    "\n",
    "\n",
    "performance_data_ranges = {}\n",
    "perf_metric_score_params = [\n",
    "    \"ell_0_norm\",\n",
    "    \"ell_1_norm\",\n",
    "    \"ell_2_norm\",\n",
    "    \"ell_inf_norm\",\n",
    "    \"total_variation\",\n",
    "    \"kl_divergence\",\n",
    "    \"average_seconds_per_sample\"\n",
    "]\n",
    "for param in perf_metric_score_params:\n",
    "    tmp = [ d[param] for d in perf_metrics_list]\n",
    "    tmp = list(filter(is_number, tmp))\n",
    "    performance_data_ranges[param] = {}\n",
    "    performance_data_ranges[param][\"min\"] = min(tmp)\n",
    "    performance_data_ranges[param][\"max\"] = max(tmp)\n",
    "\n",
    "\n",
    "print(\"\\n\\nperformance metrics ranges:\")\n",
    "pprint.pprint(performance_data_ranges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# establish weights for blended/weighted score.  These are user-selected.\n",
    "\n",
    "utility_score_weights = {}\n",
    "utility_score_weights[\"number_of_edges\"]                        = 0.05\n",
    "utility_score_weights[\"number_of_nodes\"]                        = 0.1\n",
    "utility_score_weights[\"effective_min_edge_weight_magnitude\"]    = 0.3\n",
    "utility_score_weights[\"effective_max_edge_weight_magnitude\"]    = 0.3\n",
    "utility_score_weights[\"density\"]                                = 0.05\n",
    "utility_score_weights[\"max_degree\"]                             = 0.2\n",
    "\n",
    "utility_score_parameter_sense = {}\n",
    "utility_score_parameter_sense[\"number_of_edges\"]                        = \"bigger_is_higher_score\"\n",
    "utility_score_parameter_sense[\"number_of_nodes\"]                        = \"bigger_is_higher_score\"\n",
    "utility_score_parameter_sense[\"effective_min_edge_weight_magnitude\"]    = \"smaller_is_higher_score\"\n",
    "utility_score_parameter_sense[\"effective_max_edge_weight_magnitude\"]    = \"bigger_is_higher_score\"\n",
    "utility_score_parameter_sense[\"density\"]                                = \"bigger_is_higher_score\"\n",
    "utility_score_parameter_sense[\"max_degree\"]                             = \"bigger_is_higher_score\"\n",
    "\n",
    "assert abs(sum([v for v in utility_score_weights.values()]) - 1.0) < 1e-9, \"weights don't sum to 1.0\"\n",
    "\n",
    "\n",
    "\n",
    "perf_metric_score_weights = {}\n",
    "perf_metric_score_weights[\"ell_0_norm\"]                 = 0.0 # not currently used.\n",
    "perf_metric_score_weights[\"ell_1_norm\"]                 = 0.2\n",
    "perf_metric_score_weights[\"ell_2_norm\"]                 = 0.2\n",
    "perf_metric_score_weights[\"ell_inf_norm\"]               = 0.1\n",
    "perf_metric_score_weights[\"kl_divergence\"]              = 0.2\n",
    "perf_metric_score_weights[\"total_variation\"]            = 0.2\n",
    "perf_metric_score_weights[\"average_seconds_per_sample\"] = 0.1\n",
    "\n",
    "assert abs(sum([v for v in perf_metric_score_weights.values()]) - 1.0) < 1e-9, \"weights don't sum to 1.0\"\n",
    "\n",
    "perf_metric_score_parameter_sense = {}\n",
    "perf_metric_score_parameter_sense[\"ell_0_norm\"]                 = \"smaller_is_higher_score\"\n",
    "perf_metric_score_parameter_sense[\"ell_1_norm\"]                 = \"smaller_is_higher_score\"\n",
    "perf_metric_score_parameter_sense[\"ell_2_norm\"]                 = \"smaller_is_higher_score\"\n",
    "perf_metric_score_parameter_sense[\"ell_inf_norm\"]               = \"smaller_is_higher_score\"\n",
    "perf_metric_score_parameter_sense[\"kl_divergence\"]              = \"smaller_is_higher_score\"\n",
    "perf_metric_score_parameter_sense[\"total_variation\"]            = \"smaller_is_higher_score\"\n",
    "perf_metric_score_parameter_sense[\"average_seconds_per_sample\"] = \"smaller_is_higher_score\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create scatterplot\n",
    "\n",
    "# note that we may have multiple attempts to \"solve\" one benchmark_instance.\n",
    "\n",
    "utility_scores = []\n",
    "performance_scores = []\n",
    "for p in perf_metrics_list:\n",
    "    \n",
    "    p_score = blended_performance_metric_score(\n",
    "        p,\n",
    "        performance_data_ranges,\n",
    "        perf_metric_score_weights,\n",
    "        perf_metric_score_parameter_sense\n",
    "    )\n",
    "    performance_scores.append(p_score)\n",
    "\n",
    "    # locate and score the corresponding benchmark instance for utility\n",
    "    benchmark_instance_uuid = p[\"instance_uuid\"]\n",
    "    b = {}\n",
    "    for b in instance_data_list:\n",
    "        if b[\"metadata\"][\"instance_uuid\"] == benchmark_instance_uuid:\n",
    "            break\n",
    "    u_score = blended_utility_score(\n",
    "       b,\n",
    "       instance_data_ranges,\n",
    "       utility_score_weights,\n",
    "       utility_score_parameter_sense\n",
    "    )\n",
    "    utility_scores.append(u_score)\n",
    "\n",
    "\n",
    "\n",
    "plt.scatter(performance_scores, utility_scores)\n",
    "plt.xlim([-0.1,1.1])\n",
    "plt.ylim([-0.1,1.1])\n",
    "plt.text(0.1, 0.1, s=u'\\U0001F620', fontsize=24) # frown face\n",
    "plt.text(0.1, 0.9, s=u'\\U0001F610', fontsize=24) # no opinion face\n",
    "plt.text(0.9, 0.1, s=u'\\U0001F610', fontsize=24) # no opinion face\n",
    "plt.text(0.9, 0.9, s=u'\\U0001F604', fontsize=24) # happy face\n",
    "plt.xlabel(\"Performance Score\\nBlended, Normalized relatively\")\n",
    "plt.ylabel(\"Utility Score\\nBlended, Normalized relatively\")\n",
    "plt.title(\"Utility Scaling Plot\")\n",
    "\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "sampling",
   "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}