1-The_supply_chain_graph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f72ca9c0-623b-4358-afc9-e9a7c606d102",
   "metadata": {},
   "source": [
    "# 1 - The supply chain graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73ad8843-58b9-4975-bd89-d2508ac992ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import bw2data as bd\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43798d94-b985-4c61-9c89-56f5b330c64f",
   "metadata": {},
   "source": [
    "The first thing to learn about `bw2data` is the concept of projects. Each project is self-contained, and independent of other projects. Each has its own subdirectory. This can lead to data duplication, but helps keep each project safe from the changes in the others.\n",
    "\n",
    "We start in the `default` project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "501f40ae-0f41-4cc2-9aad-c2317f9642a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.current"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0636bf15-5339-4816-9c34-a120dfc34b3d",
   "metadata": {},
   "source": [
    "It has its own directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "295ae718-fced-4833-b997-f7433352ef40",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.dir"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5e29301-038c-4cc5-a38b-3787763cdeba",
   "metadata": {},
   "source": [
    "Make it easy to reset this project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2a0c34b-f4e0-4a66-8528-a35766c792c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    bd.projects.delete_project(\"supply chain graph\", True)\n",
    "except ValueError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67681db-d546-4f1a-90c9-2f0659c768ab",
   "metadata": {},
   "source": [
    "Let's create a new project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd63cc67-aa35-424f-a671-d5ac9cc8b5f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"supply chain graph\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ed963be-9865-4f44-96c5-84b64fbe662f",
   "metadata": {},
   "source": [
    "A graph can have nodes of any type, but for the purposes of LCA it is convenient to separate activity nodes, product nodes, elementary flow nodes, and characterization nodes. We will also use a shortcut (for now) and assume that each activity produces exactly one product, so we can collapse activity and products nodes into a single node.\n",
    "\n",
    "Let's think about a simple product system - a bike. Here is a graph:\n",
    "\n",
    "<img src='images/simple-graph.png' width='400'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dd40bbf-cf56-41f4-9142-78dcee0bdab1",
   "metadata": {},
   "source": [
    "To enter this data into BW, we need to create the nodes, and then the edges. We will create these nodes in a `Database`. A database in BW is just a collection of nodes - it can be large or small, there aren't any general rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dec2934-818c-479e-ad85-1c99a88c7512",
   "metadata": {},
   "outputs": [],
   "source": [
    "db = bd.Database(\"bike\")\n",
    "# Let the metadata system know this database exists. Not necessary if using a `bw2io` importer.\n",
    "db.register()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f17ff766-fb54-4534-9d69-4d8ad51c90b9",
   "metadata": {},
   "source": [
    "Our first node. We specify some additional data to make it easier to find or use this node later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c887c7f5-c83a-40c3-9e85-430e93b837f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    'code': 'bike',\n",
    "    'name': 'bike production',\n",
    "    'location': 'DK',\n",
    "    'unit': 'bike'\n",
    "}\n",
    "\n",
    "bike = db.new_node(**data)\n",
    "bike.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c67bf17-7a15-455d-a4ca-dd477c2ebc40",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    'code': 'ng',\n",
    "    'name': 'natural gas production',\n",
    "    'location': 'NO',\n",
    "    'unit': 'MJ'\n",
    "}\n",
    "\n",
    "ng = db.new_node(**data)\n",
    "ng.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "789d250d-3a39-44f5-93ca-91e1403d1dd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    'code': 'cf',\n",
    "    'name': 'carbon fibre production',\n",
    "    'location': 'DE',\n",
    "    'unit': 'kg'\n",
    "}\n",
    "\n",
    "cf = db.new_node(**data)\n",
    "cf.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68c0bbc0-4453-49c6-94fe-2802ec1bbe3b",
   "metadata": {},
   "source": [
    "We can also define nodes like this. Note that this node has a `type`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "487752b1-1106-44fd-9a96-096059856bf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "co2 = db.new_node(\n",
    "    code='co2', \n",
    "    name=\"Carbon Dioxide\", \n",
    "    categories=('air',),\n",
    "    type='emission',\n",
    "    unit='kg'\n",
    ")\n",
    "\n",
    "co2.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c92505-3e0c-4c99-aa1f-18c681c32205",
   "metadata": {},
   "source": [
    "We also need to create edges between the nodes. We can do this in many ways, here is one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6950d13b-516f-44a5-9419-8c5bd7989ddf",
   "metadata": {},
   "outputs": [],
   "source": [
    "bike.new_edge(\n",
    "    amount=2.5, \n",
    "    type='technosphere',\n",
    "    input=cf\n",
    ").save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466d440a-9467-4f00-b2ae-bb18f567325d",
   "metadata": {},
   "source": [
    "What about some uncertainty? We use [stats_arrays](https://stats-arrays.readthedocs.io/en/latest/) to model probability distribution functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "402901ff-9553-46fb-ac89-230bd0de99c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "cf.new_edge(\n",
    "    amount=237.3,  # plus 58 kWh of electricity, in ecoinvent 3.8 \n",
    "    uncertainty_type=5, \n",
    "    minimum=200, \n",
    "    maximum=300, \n",
    "    type='technosphere',\n",
    "    input=ng,\n",
    ").save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbdf759e-20c7-4ad2-a88b-de2517bfbd67",
   "metadata": {},
   "outputs": [],
   "source": [
    "cf.new_edge(\n",
    "    amount=26.6, \n",
    "    uncertainty_type=5, \n",
    "    minimum=26,\n",
    "    maximum=27.2, \n",
    "    type='biosphere',\n",
    "    input=co2,\n",
    ").save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "794e1092-5fca-4f13-b7fe-0bfb440e70f5",
   "metadata": {},
   "source": [
    "Brightway will assume that the a `production` exchange of amount 1 in each node unless you tell it otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b14df34b-b85e-4dee-b685-454fdb5135aa",
   "metadata": {},
   "source": [
    "## LCIA\n",
    "\n",
    "To define characterization nodes and edges, we use a different data structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "413baa19-fdc7-4f93-a84a-3037d3278c8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ipcc = bd.Method(('IPCC',))\n",
    "ipcc.write([\n",
    "    (co2.key, {'amount': 1, 'uncertainty_type': 3, 'loc': 1, 'scale': 0.05}),\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a2edb6b-1695-43af-a3f9-5292c9006cd3",
   "metadata": {},
   "source": [
    "This is already enough to do an LCA. Let's check what our answer should be. Without uncertainty, to make one bike we need 2.5 kg of CF, and carbon fibre produces 26.6 kg CO2 per kg of carbon fibre, so we are looking for around 60 kg CO2-eq."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68e7940f-cbb1-418d-819f-aeafabf5cd0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import bw2calc as bc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8a87a8f-3386-4c4a-9077-63e0dbfa4953",
   "metadata": {},
   "outputs": [],
   "source": [
    "lca = bc.LCA(demand={bike: 1}, method=('IPCC',))\n",
    "lca.lci()\n",
    "lca.lcia()\n",
    "lca.score"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d33cba8-306c-4286-ab04-6353b81b0fc9",
   "metadata": {},
   "source": [
    "To use uncertainty, we tell the `LCA` object to use the probability distributions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d087957-f85b-4006-b110-bd3c336ca483",
   "metadata": {},
   "outputs": [],
   "source": [
    "lca = bc.LCA(demand={bike: 1}, method=('IPCC',), use_distributions=True)\n",
    "lca.lci()\n",
    "lca.lcia()\n",
    "\n",
    "df = pd.DataFrame([{'score': lca.score} for _ in zip(lca, range(10))])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "185b0a8b-b94e-4da8-b9c8-14be227f0bb7",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Create a new LCIA method for your iron ore consumption. Calculate the LCIA result you should get, and then verify that you have the correct value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddb5a306-2020-4cf2-a822-28eedeebf687",
   "metadata": {},
   "source": [
    "## Searching through the database\n",
    "\n",
    "In addition to storing and using nodes and edges, our graph database can be searched in different ways. Let's show this with a larger database."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "521e2ad1-4f0e-4d2b-9488-592147a4ad0e",
   "metadata": {},
   "source": [
    "We can use a shortcut to install some data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aba7543-fea8-4a41-a84e-ee436709181a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import bw2io as bi\n",
    "bi.install_project(\"USEEIO-1.1\")\n",
    "\n",
    "# If that doesn't work for whatever reason, we can import the original data with this:\n",
    "# bi.useeio11()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "611e82fd-2d4a-425c-912d-b973fd8b2e13",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"USEEIO-1.1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d23260fc-6e05-430b-aae6-b4390390372b",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.databases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdd92c2f-17b3-4d01-86ae-89dcb6d89830",
   "metadata": {},
   "outputs": [],
   "source": [
    "db = bd.Database(\"USEEIO-1.1\")\n",
    "db.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cbd2787-1293-43c6-85c1-93a09406b93e",
   "metadata": {},
   "source": [
    "This database has processes **and** products. What would this mean for drawing a graph?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "631dfa06-3322-4911-a4d7-2866a858e509",
   "metadata": {},
   "outputs": [],
   "source": [
    "{node['type'] for node in db}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f87311b8-28fd-4259-8e83-6b6a0112938f",
   "metadata": {},
   "source": [
    "We can search with the 'search' function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c66aa64d-138f-468f-b8ea-c8bafffbbbfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "fun = db.search(\"amusement\")[0]\n",
    "fun['name'] = 'fun'\n",
    "fun.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83fd3221-872e-4a29-97ea-9e9381a0d49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "db.search('amusement')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ac1549b-0780-4a97-84ea-3a719c23d14e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "{node['name'] for node in db if node['type'] == 'product'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a520b6b7-3633-4d4d-9ed7-e4407bb9ee15",
   "metadata": {},
   "source": [
    "## Interacting with the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fe2144f-665b-4442-9bcb-c9a46acd4a8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo = bd.get_node(name='Cattle ranches and feedlots', type='product')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2d44d33-a05d-4521-b703-d346e38818f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(moo) == bd.Node"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c922998-1b86-4d39-82a9-d886c6930a0a",
   "metadata": {},
   "source": [
    "We can assign any attributes to nodes (and to edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "981e7dd5-bef6-45ec-bf33-321abe9bc2e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo['moo'] = 'loud'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70d88e12-5191-44a9-917a-5cb2ad13f422",
   "metadata": {},
   "source": [
    "Note that this attributes are not saved to the database by default - we have to tell Brightway to save changed data!\n",
    "\n",
    "We have some attributes which are common to all inventory databases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1b0bea6-ff38-4a4e-9adb-0bd0e39930ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo['categories'], moo['location'], moo['unit']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "540ee517-75ef-4550-90c5-abd89a6468b7",
   "metadata": {},
   "source": [
    "The node classes act like dictionaries, and raise error for missing keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ced6e0e-140d-4cf0-9bd1-7d1b11a9af9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo['missing']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "566c30d9-4d10-4fc6-be5d-0898302df65a",
   "metadata": {},
   "source": [
    "## Exchange iterators\n",
    "\n",
    "We have shortcuts to traverse the supply chain graph. For inputs, we have `.technosphere()` and `.biospere()`; for producing edges, we have `.producers()`, and for edges to other nodes which consume the outputs of our node there is `.consumers()`. You can also get all edges with `.edges()`.\n",
    "\n",
    "These are all [iterators](https://jakevdp.github.io/WhirlwindTourOfPython/10-iterators.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de2ad280-6e61-490f-9751-e4b869289ec1",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"supply chain graph\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64e79602-2e52-49c0-80fb-61efa5509282",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.technosphere())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c810b72d-155a-4e97-9117-993b7bf9b434",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.biosphere())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78df6237-2f21-4e33-87ff-5ca321c0e697",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.consumers())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0041396-cce0-4d9c-b244-a6f2ec5ef885",
   "metadata": {},
   "source": [
    "If no edge with the type `production` is given, Brightway will assume that an activity produces one unit of its reference product, so sometimes the production edges are not given explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ebd16d3-b62d-410f-b6b3-ae06d6d5fdf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.producers())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cceb5ee8-c5e2-47a5-8062-4718f5c0270e",
   "metadata": {},
   "source": [
    "The US EEIO is the same, it is normalized to the production of one USD. It can be interesting to sum the costs of the inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9336bf62-7c8d-4a0a-b16b-ac1270805445",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"USEEIO-1.1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df9e68e2-3387-4a95-b24b-430035f1d166",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([o['amount'] for o in bd.get_node(name='Cattle ranches and feedlots', type='process').technosphere()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e02c3dc-7599-4329-89d2-874dcbc4fe39",
   "metadata": {},
   "source": [
    "# Contribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f3d70db-1daa-405f-8534-ebec445414b6",
   "metadata": {},
   "source": [
    "Let's show a little bit of what Brightway can do. We can compare the correlation of LCA scores across a variety of categories.\n",
    "\n",
    "There is an atuomatic way to do this in Brightway, but we can also program it manually to see how it works.\n",
    "\n",
    "Stop for a bit and think about what one would need to calculate LCA scores for 380 products and ~10 impact categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dc4f1a5-96ba-4f59-9957-f2b9a2b05227",
   "metadata": {},
   "outputs": [],
   "source": [
    "products_in_order = [obj for obj in db if obj['type'] == 'product']\n",
    "categories_in_order = [method for method in bd.methods if method[0] == 'Impact Potential']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a39ef0-36f5-440e-866c-ca23819335a2",
   "metadata": {},
   "source": [
    "In general, in Brightway there is *one secret* to getting good performance: Don't rebuild matrices unless you really need to. Rebuilding a matrix is not slow, but the time adds up if you do it a lot. But most importantly, if you are using `pypardiso` (normally everything except for ARM machines), and you keep the technosphere matrix the same, it will secretly remember all the preparation work it did to solve the linear system and you will get a factor of 100 speed increase on subsequent calculations.\n",
    "\n",
    "So, in this case we will use one `LCA` object, and use the `lci` method repeatedly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f83d15e4-798f-4e6e-8c38-6735c2bbe404",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "results = np.zeros((len(products_in_order), len(categories_in_order)))\n",
    "\n",
    "def get_lcia_scores(products, categories, results):\n",
    "    lca = bc.LCA({products[0]: 1}, categories[0])\n",
    "    lca.lci()\n",
    "    lca.lcia()\n",
    "    \n",
    "    method_matrices = [lca.characterization_matrix.copy()]\n",
    "    \n",
    "    for other_method in categories[1:]:\n",
    "        # Only build each characterization matrix once instead of once per product\n",
    "        lca.switch_method(other_method)\n",
    "        method_matrices.append(lca.characterization_matrix.copy())\n",
    "    \n",
    "    for i, product in enumerate(products):\n",
    "        lca.lci({product.id: 1})\n",
    "        for j, characterization_matrix in enumerate(method_matrices):\n",
    "            results[i, j] = (characterization_matrix * lca.inventory).sum()\n",
    "    \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df88c7ef-9954-45d8-8989-6811266fef3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "\n",
    "start = time()\n",
    "results = get_lcia_scores(products_in_order, categories_in_order, results)\n",
    "print(time() - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8206e376-94b6-4049-bc80-449664e41ef4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "def create_correlation_matrix(scores_array):\n",
    "    num_methods = scores_array.shape[1]\n",
    "    correlations = np.zeros((num_methods, num_methods))\n",
    "\n",
    "    for row in range(num_methods):\n",
    "        for col in range(num_methods):\n",
    "            if col <= row:\n",
    "                continue                               # Only need to compute correlation once\n",
    "            dataset_1 = scores_array[:, row]\n",
    "            dataset_2 = scores_array[:, col]\n",
    "            mask = (dataset_1 != 0) * (dataset_2 != 0) # Ignore activities that have zero score\n",
    "            corr = stats.kendalltau( # Get tau value, drop p-statistic\n",
    "                dataset_1[mask], \n",
    "                dataset_2[mask]\n",
    "            )[0]\n",
    "            if np.isnan(corr):\n",
    "                correlations[row, col] = 0\n",
    "            else:\n",
    "                correlations[row, col] = corr\n",
    "\n",
    "    correlations = correlations + correlations.T       # Make sorting easier by adding filling in lower left triangle\n",
    "    return correlations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "153a4d9c-ed3f-4cff-a1bd-c47ac9c2427e",
   "metadata": {},
   "outputs": [],
   "source": [
    "correlation_matrix = create_correlation_matrix(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "372ccc48-c5c9-41ca-aa88-414ceebc28a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78035852-533d-4e5e-8bf2-da0429f4e097",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(12, 12)\n",
    "\n",
    "masked_correlation = np.ma.array(correlation_matrix, mask=correlation_matrix == 0).T\n",
    "plt.pcolor(masked_correlation, cmap=plt.cm.cubehelix_r)\n",
    "plt.colorbar()\n",
    "plt.ylim(None, correlation_matrix.shape[1])\n",
    "plt.xlim(None, correlation_matrix.shape[0])\n",
    "plt.xticks(np.arange(0.5, 10), [obj[1] for obj in categories_in_order])\n",
    "plt.yticks(np.arange(0.5, 10), [obj[1] for obj in categories_in_order])\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed5c1470-8e9b-4194-b321-d6f235c6661a",
   "metadata": {},
   "outputs": [],
   "source": [
    "for category in categories_in_order:\n",
    "    print(category[1], bd.methods[category]['description'])"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}