diff --git a/contextualized/baselines/networks.py b/contextualized/baselines/networks.py index 66b3c3f7..c8a65585 100644 --- a/contextualized/baselines/networks.py +++ b/contextualized/baselines/networks.py @@ -38,7 +38,7 @@ def predict_w(self, model, dataloader, project_to_dag=True): preds = self.predict(model, dataloader) W = model.W.detach() * model.diag_mask if project_to_dag: - W = torch.tensor(project_to_dag_torch(W.numpy(force=True))[0]) + W = torch.tensor(project_to_dag_torch(W.numpy(force=True))) W_batch = W.unsqueeze(0).expand(len(preds), -1, -1) return W_batch.numpy() diff --git a/contextualized/dags/graph_utils.py b/contextualized/dags/graph_utils.py index 33d3f65b..88a0779e 100644 --- a/contextualized/dags/graph_utils.py +++ b/contextualized/dags/graph_utils.py @@ -88,77 +88,90 @@ def _simulate_single_equation(X, w, scale): X[:, j] = _simulate_single_equation(X[:, parents], W[parents, j], scale_vec[j]) return X +def is_dag(W): + G = ig.Graph.Weighted_Adjacency(W.tolist()) + return G.is_dag() -def break_symmetry(w): - for i in range(w.shape[0]): - w[i][i] = 0.0 - for j in range(i): - if np.abs(w[i][j]) > np.abs(w[j][i]): - w[j][i] = 0.0 - else: - w[i][j] = 0.0 - return w + +def trim_params(w, thresh=0.2): + return w * (np.abs(w) > thresh) -# w is the weighted adjacency matrix -def project_to_dag_torch(w): +def project_to_dag_torch(w, thresh=0.0): + """ + Project a weight matrix to the closest DAG in Frobenius norm. + """ + if is_dag(w): - return w, 0.0 + return w w_dag = w.copy() - w_dag = break_symmetry(w_dag) - - vals = sorted(list(set(np.abs(w_dag).flatten()))) - low = 0 - high = len(vals) - 1 - - def binary_search(arr, low, high, w): # low and high are indices - # Check base case - if high == low: - return high - if high > low: - mid = (high + low) // 2 - if mid == 0: - return mid - result = trim_params(w, arr[mid]) - if is_dag(result): - result2 = trim_params(w, arr[mid - 1]) - if is_dag(result2): # middle value is too high. go lower. - return binary_search(arr, low, mid - 1, w) - else: - return mid # found it - else: # middle value is too low. go higher. - return binary_search(arr, mid + 1, high, w) - else: - # Element is not present in the array - print("this should be impossible") - return -1 + # Easy case first: remove diagnoal entries. + w_dag *= 1 - np.eye(w.shape[0]) - idx = binary_search(vals, low, high, w_dag) + 1 - thresh = vals[idx] + # First, remove edges with weights smaller than the thresh. w_dag = trim_params(w_dag, thresh) - # Now add back in edges with weights smaller than the thresh that don't violate DAG-ness. - # want a list of edges (i, j) with weight in decreasing order. - all_vals = np.abs(w_dag).flatten() - idxs_sorted = reversed(np.argsort(all_vals)) - for idx in idxs_sorted: - i = idx // w_dag.shape[1] - j = idx % w_dag.shape[1] - if np.abs(w[i][j]) > thresh: # already retained - continue - w_dag[i][j] = w[i][j] - if not is_dag(w_dag): - w_dag[i][j] = 0.0 + # Sort nodes by magnitude of edges pointing out. + order = np.argsort(np.abs(w_dag).sum(axis=1))[::-1] + + # Re-order + w_dag = w_dag[order, :][:, order] + + # Keep only forward edges (i.e. upper triangular part). + w_dag = np.triu(w_dag) + + # Return to original order + w_dag = w_dag[np.argsort(order), :][:, np.argsort(order)] assert is_dag(w_dag) - return w_dag, thresh + return w_dag -def is_dag(W): - G = ig.Graph.Weighted_Adjacency(W.tolist()) - return G.is_dag() +def break_symmetry(w): + for i in range(w.shape[0]): + w[i][i] = 0.0 + for j in range(i): + if np.abs(w[i][j]) > np.abs(w[j][i]): + w[j][i] = 0.0 + else: + w[i][j] = 0.0 + return w -def trim_params(w, thresh=0.2): - return w * (np.abs(w) > thresh) +def project_to_dag_search(W): + W = W.copy() + if ig.Graph.Weighted_Adjacency(W).is_dag(): + return W + W_mag = np.abs(W) + W_flat = W_mag.flatten() + + # Binary search for the minimum threshold where W is a DAG, O(|E|log|E|) + weights = np.sort(W_flat) + low = 0 + mid = 0 + high = len(weights) - 1 + while low < high - 1: + new_mid = (low + high) // 2 + mid = new_mid +# print(low, mid, high) + if ig.Graph.Weighted_Adjacency(W * (W_mag > weights[mid])).is_dag(): + high = mid + else: + low = mid + W_dag = W * (W_mag > weights[high]) + + # Re-add edges we removed that don't violate the topological order, O(|E|) + p = len(W_dag) + weights_i = np.argsort(W_flat) + toposort = ig.Graph.Weighted_Adjacency(W_dag).topological_sorting() + toposort_lookup = np.zeros(p) + for topo_i, topo_node in enumerate(toposort): + toposort_lookup[topo_node] = topo_i + for sorted_i in range(high, -1, -1): + i = weights_i[sorted_i] + parent_i = i // p + child_i = i % p + if toposort_lookup[parent_i] < toposort_lookup[child_i]: + W_dag[parent_i, child_i] = weights[sorted_i] + return W_dag diff --git a/contextualized/dags/lightning_modules.py b/contextualized/dags/lightning_modules.py index 88356f2f..ba01bc6d 100644 --- a/contextualized/dags/lightning_modules.py +++ b/contextualized/dags/lightning_modules.py @@ -378,7 +378,7 @@ def _format_params(self, w_preds, **kwargs): w_preds = self._project_factor_graph_to_var(w_preds) if kwargs.get("project_to_dag", False): try: - w_preds = np.array([project_to_dag_torch(w)[0] for w in w_preds]) + w_preds = np.array([project_to_dag_torch(w) for w in w_preds]) except: print("Error, couldn't project to dag. Returning normal predictions.") return trim_params(w_preds, thresh=kwargs.get("threshold", 0.0)) diff --git a/contextualized/dags/tests.py b/contextualized/dags/tests.py index 933fbe5b..a9c282da 100644 --- a/contextualized/dags/tests.py +++ b/contextualized/dags/tests.py @@ -13,6 +13,50 @@ from contextualized.dags.trainers import GraphTrainer from contextualized.dags.losses import mse_loss as mse +class TestProjectToDag(unittest.TestCase): + """ + Test that the project_to_dag function works to create a DAG from a directed cyclic graph. + """ + def __init__(self, *args, **kwargs): + super(TestProjectToDag, self).__init__(*args, **kwargs) + + def setUp(self): + """ + Shared unit test setup code. + """ + pass + + def test_project_to_dag(self): + """ + Test that the project_to_dag function works to create a DAG from a directed cyclic graph. + """ + # Create a cyclic graph. + W = np.zeros((5, 5)) + W[0, 1] = 1 + W[1, 2] = 1 + W[2, 3] = 1 + W[3, 4] = 1 + W[4, 0] = 1 + + # Project to a DAG. + dag = graph_utils.project_to_dag_torch(W) + assert graph_utils.is_dag(dag) + + def test_project_to_dag_from_dag(self): + """ + Test that the project_to_dag function works to create a DAG from a DAG. + """ + # Create a DAG. + W = np.zeros((5, 5)) + W[0, 1] = 1 + W[1, 2] = 1 + W[2, 3] = 1 + W[3, 4] = 1 + + # Project to a DAG. + dag = graph_utils.project_to_dag_torch(W) + assert graph_utils.is_dag(dag) + class TestNOTMAD(unittest.TestCase): """Unit tests for NOTMAD.""" diff --git a/docs/demos/project_to_dag_time.ipynb b/docs/demos/project_to_dag_time.ipynb new file mode 100644 index 00000000..b672422c --- /dev/null +++ b/docs/demos/project_to_dag_time.ipynb @@ -0,0 +1,503 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "0a48df4a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from contextualized.dags.graph_utils import *\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "from contextualized.dags.losses import dag_loss_notears\n", + "import torch.optim as optim\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f19c3583", + "metadata": {}, + "outputs": [], + "source": [ + "def project_to_dag_search_old(w):\n", + " if is_dag(w):\n", + " return w, 0.0\n", + " \n", + " w_dag = w.copy()\n", + " w_dag = break_symmetry(w_dag)\n", + "\n", + " vals = sorted(list(set(np.abs(w_dag).flatten())))\n", + " low = 0\n", + " high = len(vals) - 1\n", + "\n", + " def binary_search(arr, low, high, w): # low and high are indices\n", + " # Check base case\n", + " if high == low:\n", + " return high\n", + " if high > low:\n", + " mid = (high + low) // 2\n", + " if mid == 0:\n", + " return mid\n", + " result = trim_params(w, arr[mid])\n", + " if is_dag(result):\n", + " result2 = trim_params(w, arr[mid - 1])\n", + " if is_dag(result2): # middle value is too high. go lower.\n", + " return binary_search(arr, low, mid - 1, w)\n", + " else:\n", + " return mid # found it\n", + " else: # middle value is too low. go higher.\n", + " return binary_search(arr, mid + 1, high, w)\n", + " else:\n", + " # Element is not present in the array\n", + " print(\"this should be impossible\")\n", + " return -1\n", + "\n", + " idx = binary_search(vals, low, high, w_dag) + 1\n", + " thresh = vals[idx]\n", + " w_dag = trim_params(w_dag, thresh)\n", + "\n", + " # Now add back in edges with weights smaller than the thresh that don't violate DAG-ness.\n", + " # want a list of edges (i, j) with weight in decreasing order.\n", + " all_vals = np.abs(w_dag).flatten()\n", + " idxs_sorted = reversed(np.argsort(all_vals))\n", + " for idx in idxs_sorted:\n", + " i = idx // w_dag.shape[1]\n", + " j = idx % w_dag.shape[1]\n", + " if np.abs(w[i][j]) > thresh: # already retained\n", + " continue\n", + " w_dag[i][j] = w[i][j]\n", + " if not is_dag(w_dag):\n", + " w_dag[i][j] = 0.0\n", + " assert is_dag(w_dag)\n", + " return w_dag" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "259f7f3a", + "metadata": {}, + "outputs": [], + "source": [ + "def project_to_dag_ml(w, alpha=0.01, rho=0.01, lr=1e-3, max_iter=1000, debug_mode=False):\n", + " \"\"\"\n", + " Project a weight matrix to the closest DAG using machine learning optimization\n", + " \"\"\"\n", + " if is_dag(w):\n", + " return w\n", + " w_tensor = torch.tensor(w, dtype=torch.float32, requires_grad=True) # set requires_grad for auto optim\n", + " optimizer = optim.Adam([w_tensor], lr=lr)\n", + "\n", + " for i in range(max_iter):\n", + " optimizer.zero_grad()\n", + " loss = dag_loss_notears(w_tensor, alpha=alpha, rho=rho)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " w_dag = w_tensor.detach().numpy()\n", + " w_dag = break_symmetry(w_dag)\n", + "\n", + " # make a sorted list for binary search\n", + " vals = sorted(list(set(np.abs(w_dag).flatten())))\n", + " low = 0\n", + " high = len(vals) - 1\n", + "\n", + " def binary_search(arr, low, high, w): # low and high are indices\n", + " # Check base case\n", + " if high == low:\n", + " return high\n", + " if high > low:\n", + " mid = (high + low) // 2\n", + " if mid == 0:\n", + " return mid\n", + " result = trim_params(w, arr[mid])\n", + " if is_dag(result):\n", + " result2 = trim_params(w, arr[mid - 1])\n", + " if is_dag(result2): # middle value is too high. go lower.\n", + " return binary_search(arr, low, mid - 1, w)\n", + " else:\n", + " return mid # found it\n", + " else: # middle value is too low. go higher.\n", + " return binary_search(arr, mid + 1, high, w)\n", + " else:\n", + " # Element is not present in the array\n", + " print(\"this should be impossible\")\n", + " return -1\n", + "\n", + " idx = binary_search(vals, low, high, w_dag) + 1\n", + " thresh = vals[idx]\n", + " w_dag = trim_params(w_dag, thresh)\n", + "\n", + "\n", + " if debug_mode:\n", + " print(f\"ml version shape: {w_dag.shape}\")\n", + " print(f\"ml version dag: \\n {w_dag}\")\n", + " print(f\"is dag?: {is_dag(w_dag)}\")\n", + " print(\"------------------------\")\n", + " assert is_dag(w_dag)\n", + " return w_dag" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "284a71ff", + "metadata": {}, + "outputs": [], + "source": [ + "def project_to_dag_search_no_addback(W):\n", + " W = W.copy()\n", + " if ig.Graph.Weighted_Adjacency(W).is_dag():\n", + " return W\n", + " W_mag = np.abs(W)\n", + " W_flat = W_mag.flatten()\n", + " \n", + " # Binary search for the minimum threshold where W is a DAG, O(|E|log|E|)\n", + " weights = np.sort(W_flat)\n", + " low = 0\n", + " mid = 0\n", + " high = len(weights) - 1\n", + " while low < high - 1:\n", + " new_mid = (low + high) // 2\n", + " mid = new_mid\n", + " if ig.Graph.Weighted_Adjacency(W * (W_mag > weights[mid])).is_dag():\n", + " high = mid\n", + " else:\n", + " low = mid\n", + " W_dag = W * (W_mag > weights[high])\n", + " assert(is_dag(W_dag))\n", + " return W_dag" + ] + }, + { + "cell_type": "markdown", + "id": "ea1fa89c", + "metadata": {}, + "source": [ + "### just sort, search(old), and ML" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ea7b4a19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# times\n", + "sort_times = []\n", + "search_old_times = []\n", + "ml_times = []\n", + "\n", + "# l1 distances\n", + "sort_dists_l1 = []\n", + "search_old_dists_l1 = []\n", + "ml_dists_l1 = []\n", + "\n", + "# l2 distances\n", + "sort_dists_l2 = []\n", + "search_old_dists_l2 = []\n", + "ml_dists_l2 = []\n", + "\n", + "\n", + "for n in range(2, 50):\n", + " my_sort_times = []\n", + " my_search_old_times = []\n", + " my_ml_times = []\n", + "\n", + " my_sort_dists_l2 = []\n", + " my_search_old_dists_l2 = []\n", + " my_ml_dists_l2 = []\n", + " \n", + " my_sort_dists_l1 = []\n", + " my_search_old_dists_l1 = []\n", + " my_ml_dists_l1 = []\n", + "\n", + "\n", + " for k in range(3):\n", + " w = np.random.uniform(-1, 1, size=(n,n))\n", + "\n", + " t = time.time()\n", + " w_dag = project_to_dag_torch(w)\n", + " my_sort_times.append(time.time() - t)\n", + " my_sort_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_sort_dists_l2.append(np.linalg.norm(w_dag - w))\n", + " \n", + " t = time.time()\n", + " w_dag = project_to_dag_search_old(w)\n", + " my_search_old_times.append(time.time() - t)\n", + " my_search_old_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_search_old_dists_l2.append(np.linalg.norm(w_dag - w))\n", + "\n", + " t = time.time()\n", + " w_dag = project_to_dag_ml(w, rho=0.01, alpha=0.01, lr=0.01, debug_mode=False)\n", + " my_ml_times.append(time.time() - t)\n", + " my_ml_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_ml_dists_l2.append(np.linalg.norm(w_dag - w))\n", + " \n", + " \n", + " sort_times.append(my_sort_times)\n", + " sort_dists_l1.append(my_sort_dists_l1)\n", + " sort_dists_l2.append(my_sort_dists_l2)\n", + "\n", + " search_old_times.append(my_search_old_times)\n", + " search_old_dists_l1.append(my_search_old_dists_l1)\n", + " search_old_dists_l2.append(my_search_old_dists_l2)\n", + "\n", + " ml_times.append(my_ml_times)\n", + " ml_dists_l1.append(my_ml_dists_l1)\n", + " ml_dists_l2.append(my_ml_dists_l2)\n", + " \n", + "def plot_results(results, label):\n", + " results = np.array(results)\n", + " plt.plot(np.mean(results, axis=1), label=label)\n", + " plt.fill_between(range(len(results)),\n", + " np.percentile(results, 2.5, axis=1),\n", + " np.percentile(results, 97.5, axis=1),\n", + " alpha=0.1)\n", + "plot_results(sort_times, \"By Sort\")\n", + "plot_results(search_old_times, \"By Search (old)\")\n", + "plot_results(ml_times, \"By ML\")\n", + "plt.xlabel(\"P\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.legend()\n", + "\n", + "# plotting l1 distance results\n", + "plt.figure()\n", + "plot_results(sort_dists_l1, \"By Sort\")\n", + "plot_results(search_old_dists_l1, \"By Search (old)\")\n", + "plot_results(ml_dists_l1, \"By ML\")\n", + "plt.xlabel(\"P\")\n", + "plt.ylabel(\"Project Distance (L1)\")\n", + "plt.legend()\n", + "\n", + "# plotting l2 distance results\n", + "plt.figure()\n", + "plot_results(sort_dists_l2, \"By Sort\")\n", + "plot_results(search_old_dists_l2, \"By Search (old)\")\n", + "plot_results(ml_dists_l2, \"By ML\")\n", + "plt.xlabel(\"P\")\n", + "plt.ylabel(\"Project Distance (L2)\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "8a46dcd7", + "metadata": {}, + "source": [ + "### plotting all" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ec86d97", + "metadata": {}, + "outputs": [], + "source": [ + "# times\n", + "sort_times = []\n", + "search_times = []\n", + "search_old_times = []\n", + "ml_times = []\n", + "search_times_noaddback = []\n", + "\n", + "# l1 distances\n", + "sort_dists_l1 = []\n", + "search_dists_l1 = []\n", + "search_old_dists_l1 = []\n", + "ml_dists_l1 = []\n", + "search_dists_noaddback_l1 = []\n", + "\n", + "# l2 distances\n", + "sort_dists_l2 = []\n", + "search_dists_l2 = []\n", + "search_old_dists_l2 = []\n", + "ml_dists_l2 = []\n", + "search_dists_noaddback_l2 = []\n", + "\n", + "\n", + "for n in range(2, 50):\n", + " my_sort_times = []\n", + " my_search_times = []\n", + " my_search_old_times = []\n", + " my_ml_times = []\n", + " my_search_noaddback_times = []\n", + "\n", + " my_search_dists_l2 = []\n", + " my_sort_dists_l2 = []\n", + " my_search_old_dists_l2 = []\n", + " my_ml_dists_l2 = []\n", + " my_search_noaddback_dists_l2 = []\n", + " \n", + " my_search_dists_l1 = []\n", + " my_sort_dists_l1 = []\n", + " my_search_old_dists_l1 = []\n", + " my_ml_dists_l1 = []\n", + " my_search_noaddback_dists_l1 = []\n", + "\n", + "\n", + " for k in range(3):\n", + " w = np.random.uniform(-1, 1, size=(n,n))\n", + "\n", + " t = time.time()\n", + " w_dag = project_to_dag_search(w)\n", + " my_search_times.append(time.time() - t)\n", + " my_search_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_search_dists_l2.append(np.linalg.norm(w_dag - w))\n", + " \n", + " t = time.time()\n", + " w_dag = project_to_dag_torch(w)\n", + " my_sort_times.append(time.time() - t)\n", + " my_sort_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_sort_dists_l2.append(np.linalg.norm(w_dag - w))\n", + " \n", + " t = time.time()\n", + " w_dag = project_to_dag_search_old(w)\n", + " my_search_old_times.append(time.time() - t)\n", + " my_search_old_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_search_old_dists_l2.append(np.linalg.norm(w_dag - w))\n", + "\n", + " t = time.time()\n", + " w_dag = project_to_dag_ml(w, rho=0.01, alpha=0.01, lr=0.01, debug_mode=False)\n", + " my_ml_times.append(time.time() - t)\n", + " my_ml_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_ml_dists_l2.append(np.linalg.norm(w_dag - w))\n", + " \n", + " t = time.time()\n", + " w_dag = project_to_dag_search_no_addback(w)\n", + " my_search_noaddback_times.append(time.time() - t)\n", + " my_search_noaddback_dists_l1.append(np.linalg.norm(w_dag - w, ord=1))\n", + " my_search_noaddback_dists_l2.append(np.linalg.norm(w_dag - w))\n", + "\n", + " \n", + " sort_times.append(my_sort_times)\n", + " sort_dists_l1.append(my_sort_dists_l1)\n", + " sort_dists_l2.append(my_sort_dists_l2)\n", + "\n", + " search_times.append(my_search_times)\n", + " search_dists_l1.append(my_search_dists_l1)\n", + " search_dists_l2.append(my_search_dists_l2)\n", + "\n", + " search_old_times.append(my_search_old_times)\n", + " search_old_dists_l1.append(my_search_old_dists_l1)\n", + " search_old_dists_l2.append(my_search_old_dists_l2)\n", + "\n", + " ml_times.append(my_ml_times)\n", + " ml_dists_l1.append(my_ml_dists_l1)\n", + " ml_dists_l2.append(my_ml_dists_l2)\n", + " \n", + " search_times_noaddback.append(my_search_noaddback_times)\n", + " search_dists_noaddback_l1.append(my_search_noaddback_dists_l1)\n", + " search_dists_noaddback_l2.append(my_search_noaddback_dists_l2)\n", + " \n", + "\n", + "# plotting time results\n", + "def plot_results(results, label):\n", + " results = np.array(results)\n", + " plt.plot(np.mean(results, axis=1), label=label)\n", + " plt.fill_between(range(len(results)),\n", + " np.percentile(results, 2.5, axis=1),\n", + " np.percentile(results, 97.5, axis=1),\n", + " alpha=0.1)\n", + "plot_results(sort_times, \"By Sort\")\n", + "plot_results(search_times, \"By Search\")\n", + "plot_results(search_old_times, \"By Search (old)\")\n", + "plot_results(ml_times, \"By ML\")\n", + "plot_results(search_times_noaddback, \"By search (no edge addback)\")\n", + "plt.xlabel(\"P\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.legend()\n", + "\n", + "# plotting l1 distance results\n", + "plt.figure()\n", + "plot_results(sort_dists_l1, \"By Sort\")\n", + "plot_results(search_dists_l1, \"By Search\")\n", + "plot_results(search_old_dists_l1, \"By Search (old)\")\n", + "plot_results(ml_dists_l1, \"By ML\")\n", + "plot_results(search_dists_noaddback_l1, \"By Search (no edge addback)\")\n", + "plt.xlabel(\"P\")\n", + "plt.ylabel(\"Project Distance (L1)\")\n", + "plt.legend()\n", + "\n", + "# plotting l2 distance results\n", + "plt.figure()\n", + "plot_results(sort_dists_l2, \"By Sort\")\n", + "plot_results(search_dists_l2, \"By Search\")\n", + "plot_results(search_old_dists_l2, \"By Search (old)\")\n", + "plot_results(ml_dists_l2, \"By ML\")\n", + "plot_results(search_dists_noaddback_l2, \"By Search (no edge addback)\")\n", + "plt.xlabel(\"P\")\n", + "plt.ylabel(\"Project Distance (L2)\")\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}