{"cells": [{"cell_type": "markdown", "id": "1b9d02c0", "metadata": {}, "source": ["# Use of PYBIND11_MAKE_OPAQUE\n", "\n", "[pybind11](https://pybind11.readthedocs.io/) automatically converts `std::vector` into python list. That's convenient but not necessarily efficient depending on how it is used after that. [PYBIND11_MAKE_OPAQUE](https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html#making-opaque-types) is used to create a [capsule](https://docs.python.org/3/c-api/capsule.html) to hold a pointer on the C++ object."]}, {"cell_type": "code", "execution_count": 1, "id": "f4a5179a", "metadata": {}, "outputs": [{"data": {"text/html": ["<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n", "<script>\n", "function repeat_indent_string(n){\n", "    var a = \"\" ;\n", "    for ( ; n > 0 ; --n)\n", "        a += \"    \";\n", "    return a;\n", "}\n", "// look up into all sections and builds an automated menu //\n", "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n", "    var anchors = document.getElementsByClassName(\"section\");\n", "    if (anchors.length == 0) {\n", "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n", "    }\n", "    var i,t;\n", "    var text_menu = begin;\n", "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n", "    var ind = \"\";\n", "    var memo_level = 1;\n", "    var href;\n", "    var tags = [];\n", "    var main_item = 0;\n", "    var format_open = 0;\n", "    for (i = 0; i <= llast; i++)\n", "        tags.push(\"h\" + i);\n", "\n", "    for (i = 0; i < anchors.length; i++) {\n", "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n", "\n", "        var child = null;\n", "        for(t = 0; t < tags.length; t++) {\n", "            var r = anchors[i].getElementsByTagName(tags[t]);\n", "            if (r.length > 0) {\n", "child = r[0];\n", "break;\n", "            }\n", "        }\n", "        if (child == null) {\n", "            text_memo += \"null\\n\";\n", "            continue;\n", "        }\n", "        if (anchors[i].hasAttribute(\"id\")) {\n", "            // when converted in RST\n", "            href = anchors[i].id;\n", "            text_memo += \"#1-\" + href;\n", "            // passer \u00e0 child suivant (le chercher)\n", "        }\n", "        else if (child.hasAttribute(\"id\")) {\n", "            // in a notebook\n", "            href = child.id;\n", "            text_memo += \"#2-\" + href;\n", "        }\n", "        else {\n", "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n", "            continue;\n", "        }\n", "        var title = child.textContent;\n", "        var level = parseInt(child.tagName.substring(1,2));\n", "\n", "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n", "\n", "        if ((level < lfirst) || (level > llast)) {\n", "            continue ;\n", "        }\n", "        if (title.endsWith('\u00b6')) {\n", "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n", "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n", "        }\n", "        if (title.length == 0) {\n", "            continue;\n", "        }\n", "\n", "        while (level < memo_level) {\n", "            text_menu += end_format + \"</ul>\\n\";\n", "            format_open -= 1;\n", "            memo_level -= 1;\n", "        }\n", "        if (level == lfirst) {\n", "            main_item += 1;\n", "        }\n", "        if (keep_item != -1 && main_item != keep_item + 1) {\n", "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n", "            continue;\n", "        }\n", "        while (level > memo_level) {\n", "            text_menu += \"<ul>\\n\";\n", "            memo_level += 1;\n", "        }\n", "        text_menu += repeat_indent_string(level-2);\n", "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n", "        format_open += 1;\n", "    }\n", "    while (1 < memo_level) {\n", "        text_menu += end_format + \"</ul>\\n\";\n", "        memo_level -= 1;\n", "        format_open -= 1;\n", "    }\n", "    text_menu += send;\n", "    //text_menu += \"\\n\" + text_memo;\n", "\n", "    while (format_open > 0) {\n", "        text_menu += end_format;\n", "        format_open -= 1;\n", "    }\n", "    return text_menu;\n", "};\n", "var update_menu = function() {\n", "    var sbegin = \"\";\n", "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n", "    var send = \"\";\n", "    var begin_format = '<li>';\n", "    var end_format = '</li>';\n", "    var keep_item = -1;\n", "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n", "       begin_format, end_format);\n", "    var menu = document.getElementById(\"my_id_menu_nb\");\n", "    menu.innerHTML=text_menu;\n", "};\n", "window.setTimeout(update_menu,2000);\n", "            </script>"], "text/plain": ["<IPython.core.display.HTML object>"]}, "execution_count": 2, "metadata": {}, "output_type": "execute_result"}], "source": ["from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()"]}, {"cell_type": "code", "execution_count": 2, "id": "4f747872", "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "markdown", "id": "aaf98a54", "metadata": {}, "source": ["## Two identical classes\n", "\n", "Both of then creates random vectors equivalent to `std::vector<Tensor>`, and `Tensor ~  std::vector<float>`. The first one returns a capsule due `PYBIND11_MAKE_OPAQUE(std::vector<OneTensorFloat>)` inserted into the C++ code. The other one is returning a list."]}, {"cell_type": "code", "execution_count": 3, "id": "68b5a870", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["<cpyquickhelper.examples.vector_container_python.OneTensorVector object at 0x000002B144FB5470>\n"]}], "source": ["from cpyquickhelper.examples.vector_container_python import (\n", "    RandomTensorVectorFloat, RandomTensorVectorFloat2)\n", "\n", "rnd = RandomTensorVectorFloat(10, 10)\n", "result = rnd.get_tensor_vector()\n", "print(result)"]}, {"cell_type": "code", "execution_count": 4, "id": "9e696e48", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["<cpyquickhelper.examples.vector_container_python.TensorVectorConstReferencePointer object at 0x000002B13BB8DD70>\n"]}], "source": ["result_ref = rnd.get_tensor_vector_ref()\n", "print(result_ref)"]}, {"cell_type": "code", "execution_count": 5, "id": "ffa90177", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["[<cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC4330>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC2BF0>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC2E30>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC2C30>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC2FB0>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC2970>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC26F0>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC22B0>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC21B0>, <cpyquickhelper.examples.vector_container_python.OneTensor2 object at 0x000002B144BC20F0>]\n"]}], "source": ["rnd2 = RandomTensorVectorFloat2(10, 10)\n", "result2 = rnd2.get_tensor_vector()\n", "print(result2)"]}, {"cell_type": "code", "execution_count": 6, "id": "b1c8b697", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["<cpyquickhelper.examples.vector_container_python.TensorVectorConstReferencePointer2 object at 0x000002B144EE0C30>\n"]}], "source": ["result2_ref = rnd2.get_tensor_vector_ref()\n", "print(result2_ref)"]}, {"cell_type": "code", "execution_count": 7, "id": "b51163b3", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["3.13 \u00b5s \u00b1 60.6 ns per loop (mean \u00b1 std. dev. of 7 runs, 100,000 loops each)\n"]}], "source": ["%timeit rnd.get_tensor_vector()"]}, {"cell_type": "code", "execution_count": 8, "id": "8de22452", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["1.21 \u00b5s \u00b1 38.4 ns per loop (mean \u00b1 std. dev. of 7 runs, 1,000,000 loops each)\n"]}], "source": ["%timeit rnd.get_tensor_vector_ref()"]}, {"cell_type": "code", "execution_count": 9, "id": "4466169b", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["10.4 \u00b5s \u00b1 138 ns per loop (mean \u00b1 std. dev. of 7 runs, 100,000 loops each)\n"]}], "source": ["%timeit rnd2.get_tensor_vector()"]}, {"cell_type": "code", "execution_count": 10, "id": "c716c766", "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["1.19 \u00b5s \u00b1 18.1 ns per loop (mean \u00b1 std. dev. of 7 runs, 1,000,000 loops each)\n"]}], "source": ["%timeit rnd2.get_tensor_vector_ref()"]}, {"cell_type": "markdown", "id": "e3cafd4d", "metadata": {}, "source": ["## Scenarii\n", "\n", "Three possibilities:\n", "\n", "* **list**: `std::vector<Tensor>` is converted into a list of copied Tensors\n", "* **capsule**: `std::vector<Tensor>` is converted into a capsule on a copied `std::vector<Tensor>`, the capsule still holds the pointer and is responsible to the deletion.\n", "* **ref**: `std::vector<Tensor>` is just return as a pointer. The cost of getting the pointer does not depend on the content size. It is somehow the low limit."]}, {"cell_type": "markdown", "id": "f2ed080e", "metadata": {}, "source": ["## Plots"]}, {"cell_type": "code", "execution_count": 11, "id": "7cd2b82d", "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 144/144 [00:19<00:00,  7.43it/s]\n"]}, {"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>average</th>\n", "      <th>deviation</th>\n", "      <th>min_exec</th>\n", "      <th>max_exec</th>\n", "      <th>repeat</th>\n", "      <th>number</th>\n", "      <th>ttime</th>\n", "      <th>context_size</th>\n", "      <th>name</th>\n", "      <th>n_vectors</th>\n", "      <th>size</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>409</th>\n", "      <td>0.018321</td>\n", "      <td>0.000367</td>\n", "      <td>0.018026</td>\n", "      <td>0.018838</td>\n", "      <td>3</td>\n", "      <td>3</td>\n", "      <td>0.054962</td>\n", "      <td>64</td>\n", "      <td>list</td>\n", "      <td>10000</td>\n", "      <td>200</td>\n", "    </tr>\n", "    <tr>\n", "      <th>410</th>\n", "      <td>0.000002</td>\n", "      <td>0.000001</td>\n", "      <td>0.000001</td>\n", "      <td>0.000004</td>\n", "      <td>3</td>\n", "      <td>3</td>\n", "      <td>0.000007</td>\n", "      <td>64</td>\n", "      <td>ref</td>\n", "      <td>10000</td>\n", "      <td>200</td>\n", "    </tr>\n", "    <tr>\n", "      <th>411</th>\n", "      <td>0.010974</td>\n", "      <td>0.000492</td>\n", "      <td>0.010512</td>\n", "      <td>0.011656</td>\n", "      <td>3</td>\n", "      <td>3</td>\n", "      <td>0.032923</td>\n", "      <td>64</td>\n", "      <td>capsule</td>\n", "      <td>10000</td>\n", "      <td>500</td>\n", "    </tr>\n", "    <tr>\n", "      <th>412</th>\n", "      <td>0.035484</td>\n", "      <td>0.000900</td>\n", "      <td>0.034286</td>\n", "      <td>0.036456</td>\n", "      <td>3</td>\n", "      <td>3</td>\n", "      <td>0.106451</td>\n", "      <td>64</td>\n", "      <td>list</td>\n", "      <td>10000</td>\n", "      <td>500</td>\n", "    </tr>\n", "    <tr>\n", "      <th>413</th>\n", "      <td>0.000003</td>\n", "      <td>0.000002</td>\n", "      <td>0.000001</td>\n", "      <td>0.000005</td>\n", "      <td>3</td>\n", "      <td>3</td>\n", "      <td>0.000008</td>\n", "      <td>64</td>\n", "      <td>ref</td>\n", "      <td>10000</td>\n", "      <td>500</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["      average  deviation  min_exec  max_exec  repeat  number     ttime  \\\n", "409  0.018321   0.000367  0.018026  0.018838       3       3  0.054962   \n", "410  0.000002   0.000001  0.000001  0.000004       3       3  0.000007   \n", "411  0.010974   0.000492  0.010512  0.011656       3       3  0.032923   \n", "412  0.035484   0.000900  0.034286  0.036456       3       3  0.106451   \n", "413  0.000003   0.000002  0.000001  0.000005       3       3  0.000008   \n", "\n", "     context_size     name  n_vectors  size  \n", "409            64     list      10000   200  \n", "410            64      ref      10000   200  \n", "411            64  capsule      10000   500  \n", "412            64     list      10000   500  \n", "413            64      ref      10000   500  "]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["import itertools\n", "from cpyquickhelper.numbers.speed_measure import measure_time\n", "from tqdm import tqdm\n", "import pandas\n", "\n", "data = []\n", "sizes = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 5000, 10000]\n", "sizes = list(itertools.product(sizes, sizes))\n", "for i, j in tqdm(sizes):\n", "    if j >= 1000:\n", "        if i > 1000:\n", "            continue\n", "    if i * j >= 1e6:\n", "        repeat, number = 3, 3\n", "    else:\n", "        repeat, number = 10, 10\n", "    rnd = RandomTensorVectorFloat(i, j)\n", "    obs = measure_time(lambda: rnd.get_tensor_vector(), repeat=repeat, number=number, div_by_number=True)\n", "    obs['name'] = 'capsule'\n", "    obs['n_vectors'] = i\n", "    obs['size'] = j\n", "    data.append(obs)\n", "\n", "    rnd2 = RandomTensorVectorFloat2(i, j)\n", "    obs = measure_time(lambda: rnd2.get_tensor_vector(), repeat=repeat, number=number, div_by_number=True)\n", "    obs['name'] = 'list'\n", "    obs['n_vectors'] = i\n", "    obs['size'] = j\n", "    data.append(obs)\n", "\n", "    obs = measure_time(lambda: rnd2.get_tensor_vector_ref(), repeat=repeat, number=number, div_by_number=True)\n", "    obs['name'] = 'ref'\n", "    obs['n_vectors'] = i\n", "    obs['size'] = j\n", "    data.append(obs)\n", "    \n", "df = pandas.DataFrame(data)\n", "df.tail()"]}, {"cell_type": "code", "execution_count": 12, "id": "e66b1106", "metadata": {}, "outputs": [{"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>name</th>\n", "      <th>capsule</th>\n", "      <th>list</th>\n", "      <th>ref</th>\n", "      <th>ratio</th>\n", "    </tr>\n", "    <tr>\n", "      <th>n_vectors</th>\n", "      <th>size</th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th rowspan=\"5\" valign=\"top\">10000</th>\n", "      <th>20</th>\n", "      <td>0.001611</td>\n", "      <td>0.009616</td>\n", "      <td>0.000001</td>\n", "      <td>0.167512</td>\n", "    </tr>\n", "    <tr>\n", "      <th>50</th>\n", "      <td>0.001892</td>\n", "      <td>0.010399</td>\n", "      <td>0.000001</td>\n", "      <td>0.181907</td>\n", "    </tr>\n", "    <tr>\n", "      <th>100</th>\n", "      <td>0.002597</td>\n", "      <td>0.014054</td>\n", "      <td>0.000002</td>\n", "      <td>0.184789</td>\n", "    </tr>\n", "    <tr>\n", "      <th>200</th>\n", "      <td>0.004847</td>\n", "      <td>0.018321</td>\n", "      <td>0.000002</td>\n", "      <td>0.264565</td>\n", "    </tr>\n", "    <tr>\n", "      <th>500</th>\n", "      <td>0.010974</td>\n", "      <td>0.035484</td>\n", "      <td>0.000003</td>\n", "      <td>0.309278</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["name             capsule      list       ref     ratio\n", "n_vectors size                                        \n", "10000     20    0.001611  0.009616  0.000001  0.167512\n", "          50    0.001892  0.010399  0.000001  0.181907\n", "          100   0.002597  0.014054  0.000002  0.184789\n", "          200   0.004847  0.018321  0.000002  0.264565\n", "          500   0.010974  0.035484  0.000003  0.309278"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["piv = pandas.pivot_table(df, index=['n_vectors', 'size'], columns=['name'], values='average')\n", "piv['ratio'] = piv['capsule'] / piv['list']\n", "piv.tail()"]}, {"cell_type": "code", "execution_count": 13, "id": "23ccccc5", "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 720x288 with 2 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1, 2, figsize=(10, 4))\n", "piv[['capsule', 'list', 'ref']].plot(logy=True, ax=ax[0], title='Capsule (OPAQUE) / list')\n", "piv.sort_values('ratio', ascending=False)[['ratio']].plot(ax=ax[1], title='Ratio Capsule (OPAQUE) / list');"]}, {"cell_type": "code", "execution_count": 14, "id": "2fde92f9", "metadata": {}, "outputs": [{"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th>size</th>\n", "      <th>1</th>\n", "      <th>2</th>\n", "      <th>5</th>\n", "      <th>10</th>\n", "      <th>20</th>\n", "      <th>50</th>\n", "      <th>100</th>\n", "      <th>200</th>\n", "      <th>500</th>\n", "      <th>1000</th>\n", "      <th>5000</th>\n", "      <th>10000</th>\n", "    </tr>\n", "    <tr>\n", "      <th>n_vectors</th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>0.566917</td>\n", "      <td>1.130723</td>\n", "      <td>0.995022</td>\n", "      <td>1.023320</td>\n", "      <td>1.028793</td>\n", "      <td>1.612390</td>\n", "      <td>0.943035</td>\n", "      <td>1.717130</td>\n", "      <td>1.284653</td>\n", "      <td>0.973898</td>\n", "      <td>1.083473</td>\n", "      <td>0.663566</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>0.862783</td>\n", "      <td>0.757669</td>\n", "      <td>0.775862</td>\n", "      <td>0.775123</td>\n", "      <td>0.829735</td>\n", "      <td>0.763393</td>\n", "      <td>0.776532</td>\n", "      <td>0.762319</td>\n", "      <td>0.871343</td>\n", "      <td>0.699622</td>\n", "      <td>0.612026</td>\n", "      <td>0.539308</td>\n", "    </tr>\n", "    <tr>\n", "      <th>5</th>\n", "      <td>0.379608</td>\n", "      <td>0.555293</td>\n", "      <td>0.368967</td>\n", "      <td>0.470159</td>\n", "      <td>0.378897</td>\n", "      <td>0.410572</td>\n", "      <td>0.589214</td>\n", "      <td>0.434686</td>\n", "      <td>0.395905</td>\n", "      <td>0.419958</td>\n", "      <td>0.461235</td>\n", "      <td>0.473515</td>\n", "    </tr>\n", "    <tr>\n", "      <th>10</th>\n", "      <td>0.301479</td>\n", "      <td>0.316046</td>\n", "      <td>0.374528</td>\n", "      <td>0.303198</td>\n", "      <td>0.407169</td>\n", "      <td>0.359681</td>\n", "      <td>0.288451</td>\n", "      <td>0.360526</td>\n", "      <td>0.402298</td>\n", "      <td>0.398315</td>\n", "      <td>0.393545</td>\n", "      <td>0.439519</td>\n", "    </tr>\n", "    <tr>\n", "      <th>20</th>\n", "      <td>0.356484</td>\n", "      <td>0.251247</td>\n", "      <td>0.230067</td>\n", "      <td>0.210293</td>\n", "      <td>0.252366</td>\n", "      <td>0.255456</td>\n", "      <td>0.288205</td>\n", "      <td>0.284486</td>\n", "      <td>0.252392</td>\n", "      <td>0.257864</td>\n", "      <td>0.416393</td>\n", "      <td>0.043764</td>\n", "    </tr>\n", "    <tr>\n", "      <th>50</th>\n", "      <td>0.231620</td>\n", "      <td>0.220888</td>\n", "      <td>0.210009</td>\n", "      <td>0.216061</td>\n", "      <td>0.214163</td>\n", "      <td>0.282138</td>\n", "      <td>0.266862</td>\n", "      <td>0.206823</td>\n", "      <td>0.263674</td>\n", "      <td>0.339590</td>\n", "      <td>0.039424</td>\n", "      <td>0.493669</td>\n", "    </tr>\n", "    <tr>\n", "      <th>100</th>\n", "      <td>0.394659</td>\n", "      <td>0.189204</td>\n", "      <td>0.256503</td>\n", "      <td>0.206615</td>\n", "      <td>0.214958</td>\n", "      <td>0.218592</td>\n", "      <td>0.240267</td>\n", "      <td>0.225569</td>\n", "      <td>0.243605</td>\n", "      <td>0.314168</td>\n", "      <td>0.412960</td>\n", "      <td>0.406809</td>\n", "    </tr>\n", "    <tr>\n", "      <th>200</th>\n", "      <td>0.201795</td>\n", "      <td>0.189723</td>\n", "      <td>0.211110</td>\n", "      <td>0.197427</td>\n", "      <td>0.212577</td>\n", "      <td>0.212658</td>\n", "      <td>0.212798</td>\n", "      <td>0.225500</td>\n", "      <td>0.257274</td>\n", "      <td>0.277588</td>\n", "      <td>0.439891</td>\n", "      <td>0.427631</td>\n", "    </tr>\n", "    <tr>\n", "      <th>500</th>\n", "      <td>0.189678</td>\n", "      <td>0.169699</td>\n", "      <td>0.188959</td>\n", "      <td>0.193446</td>\n", "      <td>0.184101</td>\n", "      <td>0.209909</td>\n", "      <td>0.205913</td>\n", "      <td>0.229271</td>\n", "      <td>0.243023</td>\n", "      <td>0.110660</td>\n", "      <td>0.472577</td>\n", "      <td>0.456907</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1000</th>\n", "      <td>0.181940</td>\n", "      <td>0.183248</td>\n", "      <td>0.183335</td>\n", "      <td>0.186856</td>\n", "      <td>0.191277</td>\n", "      <td>0.195801</td>\n", "      <td>0.197123</td>\n", "      <td>0.209983</td>\n", "      <td>0.262004</td>\n", "      <td>0.184530</td>\n", "      <td>0.471995</td>\n", "      <td>0.467629</td>\n", "    </tr>\n", "    <tr>\n", "      <th>5000</th>\n", "      <td>0.183440</td>\n", "      <td>0.179145</td>\n", "      <td>0.178354</td>\n", "      <td>0.179633</td>\n", "      <td>0.178630</td>\n", "      <td>0.185844</td>\n", "      <td>0.194558</td>\n", "      <td>0.160261</td>\n", "      <td>0.334000</td>\n", "      <td>NaN</td>\n", "      <td>NaN</td>\n", "      <td>NaN</td>\n", "    </tr>\n", "    <tr>\n", "      <th>10000</th>\n", "      <td>0.178259</td>\n", "      <td>0.174690</td>\n", "      <td>0.172229</td>\n", "      <td>0.166271</td>\n", "      <td>0.167512</td>\n", "      <td>0.181907</td>\n", "      <td>0.184789</td>\n", "      <td>0.264565</td>\n", "      <td>0.309278</td>\n", "      <td>NaN</td>\n", "      <td>NaN</td>\n", "      <td>NaN</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["size          1         2         5         10        20        50     \\\n", "n_vectors                                                               \n", "1          0.566917  1.130723  0.995022  1.023320  1.028793  1.612390   \n", "2          0.862783  0.757669  0.775862  0.775123  0.829735  0.763393   \n", "5          0.379608  0.555293  0.368967  0.470159  0.378897  0.410572   \n", "10         0.301479  0.316046  0.374528  0.303198  0.407169  0.359681   \n", "20         0.356484  0.251247  0.230067  0.210293  0.252366  0.255456   \n", "50         0.231620  0.220888  0.210009  0.216061  0.214163  0.282138   \n", "100        0.394659  0.189204  0.256503  0.206615  0.214958  0.218592   \n", "200        0.201795  0.189723  0.211110  0.197427  0.212577  0.212658   \n", "500        0.189678  0.169699  0.188959  0.193446  0.184101  0.209909   \n", "1000       0.181940  0.183248  0.183335  0.186856  0.191277  0.195801   \n", "5000       0.183440  0.179145  0.178354  0.179633  0.178630  0.185844   \n", "10000      0.178259  0.174690  0.172229  0.166271  0.167512  0.181907   \n", "\n", "size          100       200       500       1000      5000      10000  \n", "n_vectors                                                              \n", "1          0.943035  1.717130  1.284653  0.973898  1.083473  0.663566  \n", "2          0.776532  0.762319  0.871343  0.699622  0.612026  0.539308  \n", "5          0.589214  0.434686  0.395905  0.419958  0.461235  0.473515  \n", "10         0.288451  0.360526  0.402298  0.398315  0.393545  0.439519  \n", "20         0.288205  0.284486  0.252392  0.257864  0.416393  0.043764  \n", "50         0.266862  0.206823  0.263674  0.339590  0.039424  0.493669  \n", "100        0.240267  0.225569  0.243605  0.314168  0.412960  0.406809  \n", "200        0.212798  0.225500  0.257274  0.277588  0.439891  0.427631  \n", "500        0.205913  0.229271  0.243023  0.110660  0.472577  0.456907  \n", "1000       0.197123  0.209983  0.262004  0.184530  0.471995  0.467629  \n", "5000       0.194558  0.160261  0.334000       NaN       NaN       NaN  \n", "10000      0.184789  0.264565  0.309278       NaN       NaN       NaN  "]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["flat = piv.reset_index(drop=False)[['n_vectors', 'size', 'ratio']]\n", "flat_piv = flat.pivot('n_vectors', 'size', 'ratio')\n", "flat_piv"]}, {"cell_type": "code", "execution_count": 15, "id": "b69db209", "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 2 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["import numpy\n", "import seaborn\n", "seaborn.heatmap(numpy.minimum(flat_piv.values, 1), cmap=\"YlGnBu\",\n", "                xticklabels=list(flat_piv.index), yticklabels=list(flat_piv.columns));"]}, {"cell_type": "code", "execution_count": 16, "id": "7449de78", "metadata": {}, "outputs": [], "source": []}, {"cell_type": "code", "execution_count": 17, "id": "45756699", "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.9.5"}}, "nbformat": 4, "nbformat_minor": 5}