{"cells": [{"cell_type": "markdown", "id": "a5ccea37", "metadata": {}, "source": ["# Lightgbm, double, discrepencies\n", "\n", "Discrepencies usually happens with [lightgbm](https://lightgbm.readthedocs.io/en/latest/) because its code is used double to represent the threshold of trees as ONNX is using float only. There is no way to fix this discrepencies unless the ONNX implementation of trees is using double."]}, {"cell_type": "code", "execution_count": 1, "id": "e40e5998", "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": "6e7deac3", "metadata": {}, "outputs": [], "source": ["%load_ext mlprodict"]}, {"cell_type": "markdown", "id": "2771dacd", "metadata": {}, "source": ["## Simple regression problem\n", "\n", "Target *y* is multiplied by 10 to increase the absolute discrepencies. Relative discrepencies should not change much."]}, {"cell_type": "code", "execution_count": 3, "id": "6f9b8191", "metadata": {}, "outputs": [], "source": ["from sklearn.datasets import make_regression\n", "from sklearn.model_selection import train_test_split\n", "X, y = make_regression(2000, n_features=10)\n", "y *= 10\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)"]}, {"cell_type": "code", "execution_count": 4, "id": "9c5084f3", "metadata": {}, "outputs": [{"data": {"text/plain": ["(-5645.317056441552, 5686.0775071009075)"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["min(y), max(y)"]}, {"cell_type": "markdown", "id": "0f6c8d61", "metadata": {}, "source": ["## Training a model\n", "\n", "Let's train many models to see how they behave."]}, {"cell_type": "code", "execution_count": 5, "id": "21709d93", "metadata": {}, "outputs": [], "source": ["from sklearn.ensemble import RandomForestRegressor\n", "from sklearn.ensemble import GradientBoostingRegressor\n", "from sklearn.ensemble import HistGradientBoostingRegressor\n", "from lightgbm import LGBMRegressor\n", "from xgboost import XGBRegressor"]}, {"cell_type": "code", "execution_count": 6, "id": "7242d2d1", "metadata": {}, "outputs": [], "source": ["models = [\n", "    RandomForestRegressor(n_estimators=50, max_depth=8),\n", "    GradientBoostingRegressor(n_estimators=50, max_depth=8),\n", "    HistGradientBoostingRegressor(max_iter=50, max_depth=8),\n", "    LGBMRegressor(n_estimators=50, max_depth=8),\n", "    XGBRegressor(n_estimators=50, max_depth=8),\n", "]"]}, {"cell_type": "code", "execution_count": 7, "id": "a1fe232b", "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5/5 [00:01<00:00,  3.96it/s]\n"]}], "source": ["from tqdm import tqdm\n", "for model in tqdm(models):\n", "    model.fit(X_train, y_train)"]}, {"cell_type": "markdown", "id": "890ac0aa", "metadata": {}, "source": ["## Conversion to ONNX\n", "\n", "We use function *to_onnx* from this package to avoid the trouble of registering converters from *onnxmltools* for *lightgbm* and *xgboost* libraries."]}, {"cell_type": "code", "execution_count": 8, "id": "3d971c02", "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["C:\\xavierdupre\\__home_\\github_fork\\scikit-learn\\sklearn\\utils\\deprecation.py:101: FutureWarning: Attribute n_features_ was deprecated in version 1.0 and will be removed in 1.2. Use 'n_features_in_' instead.\n", "  warnings.warn(msg, category=FutureWarning)\n", "C:\\xavierdupre\\__home_\\github_fork\\scikit-learn\\sklearn\\utils\\deprecation.py:101: FutureWarning: Attribute n_classes_ was deprecated in version 0.24 and will be removed in 1.1 (renaming of 0.26).\n", "  warnings.warn(msg, category=FutureWarning)\n"]}], "source": ["from mlprodict.onnx_conv import to_onnx\n", "import numpy\n", "onnx_models = [to_onnx(model, X_train[:1].astype(numpy.float32), rewrite_ops=True)\n", "               for model in models]"]}, {"cell_type": "code", "execution_count": 9, "id": "22558f9f", "metadata": {}, "outputs": [{"data": {"text/html": ["<div id=\"M2fe559de0a2442248dd225087eb42196-cont\"><div id=\"M2fe559de0a2442248dd225087eb42196\" style=\"width:100%;height:100%;\"></div></div>\n", "<script>\n", "\n", "require(['http://www.xavierdupre.fr/js/vizjs/viz.js'], function() { var svgGraph = Viz(\"digraph{\\n  orientation=portrait;\\n  size=None;\\n  nodesep=0.05;\\n  ranksep=0.25;\\n\\n  X [shape=box color=red label=\\\"X\\nfloat((0, 10))\\\" fontsize=10];\\n\\n  variable [shape=box color=green label=\\\"variable\\nfloat((0, 1))\\\" fontsize=10];\\n\\n\\n  LightGbmLGBMRegressor [shape=box style=\\\"filled,rounded\\\" color=orange label=\\\"TreeEnsembleRegressor\\n(LightGbmLGBMRegressor)\\nn_targets=1\\nnodes_falsenodeids=[ 2  4 16  6...\\nnodes_featureids=[6 9 9 5 2 0 1...\\nnodes_hitrates=[1. 1. 1. 1. 1. ...\\nnodes_missing_value_tracks_true=[1 1 1 1 1...\\nnodes_modes=[b'BRANCH_LEQ' b'BR...\\nnodes_nodeids=[ 0  1  2  3  4  ...\\nnodes_treeids=[0 0 0 0 0 0 0 0 ...\\nnodes_truenodeids=[ 1  3 15  5 ...\\nnodes_values=[-0.3632275  -0.02...\\npost_transform=b'NONE'\\ntarget_ids=[0 0 0 0 0 0 0 0 0 0...\\ntarget_nodeids=[ 5  7  8 11 12 ...\\ntarget_treeids=[0 0 0 0 0 0 0 0...\\ntarget_weights=[-295.27792  -20...\\\" fontsize=10];\\n  X -> LightGbmLGBMRegressor;\\n  LightGbmLGBMRegressor -> variable;\\n}\");\n", "document.getElementById('M2fe559de0a2442248dd225087eb42196').innerHTML = svgGraph; });\n", "\n", "</script>"], "text/plain": ["<jyquickhelper.jspy.render_nb_js_dot.RenderJsDot at 0x26eb25dfb80>"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}], "source": ["simple_onx = to_onnx(LGBMRegressor(n_estimators=3, max_depth=4).fit(X_train, y_train),\n", "                     X_train[:1].astype(numpy.float32), rewrite_ops=True)\n", "%onnxview simple_onx"]}, {"cell_type": "markdown", "id": "118ad3d6", "metadata": {}, "source": ["## Discrepencies with float32"]}, {"cell_type": "code", "execution_count": 10, "id": "9314a1c2", "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>max_diff</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>RandomForestRegressor</td>\n", "      <td>0.000493</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>GradientBoostingRegressor</td>\n", "      <td>0.000937</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>HistGradientBoostingRegressor</td>\n", "      <td>0.000794</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>LGBMRegressor</td>\n", "      <td>0.000924</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>XGBRegressor</td>\n", "      <td>0.000977</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                            name  max_diff\n", "0          RandomForestRegressor  0.000493\n", "1      GradientBoostingRegressor  0.000937\n", "2  HistGradientBoostingRegressor  0.000794\n", "3                  LGBMRegressor  0.000924\n", "4                   XGBRegressor  0.000977"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["from onnxruntime import InferenceSession\n", "from pandas import DataFrame\n", "\n", "\n", "def max_discrepency(X, skl_model, onx_model):\n", "    expected = skl_model.predict(X).ravel()\n", "    \n", "    sess = InferenceSession(onx_model.SerializeToString())\n", "    got = sess.run(None, {'X': X})[0].ravel()\n", "    \n", "    diff = numpy.abs(got - expected).max()\n", "    return diff\n", "\n", "\n", "obs = []\n", "x32 = X_test.astype(numpy.float32)\n", "for model, onx in zip(models, onnx_models):\n", "    diff = max_discrepency(x32, model, onx)\n", "    obs.append(dict(name=model.__class__.__name__, max_diff=diff))\n", "\n", "    \n", "DataFrame(obs)"]}, {"cell_type": "code", "execution_count": 11, "id": "0d31721e", "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["DataFrame(obs).set_index(\"name\").plot(kind=\"bar\").set_title(\"onnxruntime + float32\");"]}, {"cell_type": "markdown", "id": "80b77826", "metadata": {}, "source": ["## Discrepencies with mlprodict\n", "\n", "This is not available with the current standard ONNX specifications. It required *mlprodict* to implement a runtime for tree ensemble supporting doubles."]}, {"cell_type": "code", "execution_count": 12, "id": "a6a3b047", "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>max_diff</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>RandomForestRegressor</td>\n", "      <td>0.000798</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>GradientBoostingRegressor</td>\n", "      <td>0.001440</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>HistGradientBoostingRegressor</td>\n", "      <td>0.001082</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>LGBMRegressor</td>\n", "      <td>0.001288</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>XGBRegressor</td>\n", "      <td>0.000122</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                            name  max_diff\n", "0          RandomForestRegressor  0.000798\n", "1      GradientBoostingRegressor  0.001440\n", "2  HistGradientBoostingRegressor  0.001082\n", "3                  LGBMRegressor  0.001288\n", "4                   XGBRegressor  0.000122"]}, "execution_count": 13, "metadata": {}, "output_type": "execute_result"}], "source": ["from mlprodict.onnxrt import OnnxInference\n", "from pandas import DataFrame\n", "\n", "\n", "def max_discrepency_2(X, skl_model, onx_model):\n", "    expected = skl_model.predict(X).ravel()\n", "    \n", "    sess = OnnxInference(onx_model)\n", "    got = sess.run({'X': X})['variable'].ravel()\n", "    \n", "    diff = numpy.abs(got - expected).max()\n", "    return diff\n", "\n", "\n", "obs = []\n", "x32 = X_test.astype(numpy.float32)\n", "for model, onx in zip(models, onnx_models):\n", "    diff = max_discrepency_2(x32, model, onx)\n", "    obs.append(dict(name=model.__class__.__name__, max_diff=diff))\n", "\n", "    \n", "DataFrame(obs)"]}, {"cell_type": "code", "execution_count": 13, "id": "59f6a627", "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["DataFrame(obs).set_index(\"name\").plot(kind=\"bar\").set_title(\"mlprodict + float32\");"]}, {"cell_type": "markdown", "id": "5d323d95", "metadata": {}, "source": ["## Discrepencies with mlprodict and double\n", "\n", "The conversion needs to happen again."]}, {"cell_type": "code", "execution_count": 14, "id": "ce3c083f", "metadata": {"scrolled": false}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["C:\\xavierdupre\\microsoft_github\\sklearn-onnx\\skl2onnx\\common\\_container.py:603: UserWarning: Unable to find operator 'TreeEnsembleRegressorDouble' in domain 'mlprodict' in ONNX, op_version is forced to 1.\n", "  warnings.warn(\n"]}, {"data": {"text/html": ["<div id=\"Mce0da6d95aad4720ba80e53a6e3c907c-cont\"><div id=\"Mce0da6d95aad4720ba80e53a6e3c907c\" style=\"width:100%;height:100%;\"></div></div>\n", "<script>\n", "\n", "require(['http://www.xavierdupre.fr/js/vizjs/viz.js'], function() { var svgGraph = Viz(\"digraph{\\n  orientation=portrait;\\n  size=None;\\n  nodesep=0.05;\\n  ranksep=0.25;\\n\\n  X [shape=box color=red label=\\\"X\\ndouble((0, 10))\\\" fontsize=10];\\n\\n  variable [shape=box color=green label=\\\"variable\\ndouble((0, 1))\\\" fontsize=10];\\n\\n\\n  LightGbmLGBMRegressor [shape=box style=\\\"filled,rounded\\\" color=orange label=\\\"TreeEnsembleRegressorDouble\\n(LightGbmLGBMRegressor)\\nn_targets=1\\nnodes_falsenodeids=[2 4 6 0 0 0...\\nnodes_featureids=[6 9 9 0 0 0 0...\\nnodes_hitrates=[1. 1. 1. 1. 1. ...\\nnodes_missing_value_tracks_true=[1 1 1 0 0...\\nnodes_modes=[b'BRANCH_LEQ' b'BR...\\nnodes_nodeids=[0 1 2 3 4 5 6 0 ...\\nnodes_treeids=[0 0 0 0 0 0 0 1 ...\\nnodes_truenodeids=[1 3 5 0 0 0 ...\\nnodes_values=[-0.3632275  -0.02...\\npost_transform=b'NONE'\\ntarget_ids=[0 0 0 0 0 0 0 0]\\ntarget_nodeids=[3 4 5 6 3 4 5 6...\\ntarget_treeids=[0 0 0 0 1 1 1 1...\\ntarget_weights=[-164.93028    -...\\\" fontsize=10];\\n  X -> LightGbmLGBMRegressor;\\n  LightGbmLGBMRegressor -> variable;\\n}\");\n", "document.getElementById('Mce0da6d95aad4720ba80e53a6e3c907c').innerHTML = svgGraph; });\n", "\n", "</script>"], "text/plain": ["<jyquickhelper.jspy.render_nb_js_dot.RenderJsDot at 0x26eb8284130>"]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["simple_onx = to_onnx(LGBMRegressor(n_estimators=2, max_depth=2).fit(X_train, y_train),\n", "                     X_train[:1].astype(numpy.float64), rewrite_ops=True)\n", "%onnxview simple_onx"]}, {"cell_type": "code", "execution_count": 15, "id": "cc79b343", "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["  0%|          | 0/5 [00:00<?, ?it/s]C:\\xavierdupre\\__home_\\github_fork\\scikit-learn\\sklearn\\utils\\deprecation.py:101: FutureWarning: Attribute n_features_ was deprecated in version 1.0 and will be removed in 1.2. Use 'n_features_in_' instead.\n", "  warnings.warn(msg, category=FutureWarning)\n", " 20%|\u2588\u2588        | 1/5 [00:02<00:09,  2.40s/it]C:\\xavierdupre\\__home_\\github_fork\\scikit-learn\\sklearn\\utils\\deprecation.py:101: FutureWarning: Attribute n_classes_ was deprecated in version 0.24 and will be removed in 1.1 (renaming of 0.26).\n", "  warnings.warn(msg, category=FutureWarning)\n", "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5/5 [00:04<00:00,  1.16it/s]\n"]}], "source": ["onnx_models_64 = []\n", "for model in tqdm(models):\n", "    onx = to_onnx(model, X_train[:1].astype(numpy.float64), rewrite_ops=True)\n", "    onnx_models_64.append(onx)"]}, {"cell_type": "code", "execution_count": 16, "id": "9bf72d4c", "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>max_diff</th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>0</th>\n", "      <td>RandomForestRegressor</td>\n", "      <td>2.273737e-12</td>\n", "    </tr>\n", "    <tr>\n", "      <th>1</th>\n", "      <td>GradientBoostingRegressor</td>\n", "      <td>9.094947e-13</td>\n", "    </tr>\n", "    <tr>\n", "      <th>2</th>\n", "      <td>HistGradientBoostingRegressor</td>\n", "      <td>9.094947e-13</td>\n", "    </tr>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>LGBMRegressor</td>\n", "      <td>4.686752e-05</td>\n", "    </tr>\n", "    <tr>\n", "      <th>4</th>\n", "      <td>XGBRegressor</td>\n", "      <td>1.562066e-03</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                            name      max_diff\n", "0          RandomForestRegressor  2.273737e-12\n", "1      GradientBoostingRegressor  9.094947e-13\n", "2  HistGradientBoostingRegressor  9.094947e-13\n", "3                  LGBMRegressor  4.686752e-05\n", "4                   XGBRegressor  1.562066e-03"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["obs64 = []\n", "x64 = X_test.astype(numpy.float64)\n", "for model, onx in zip(models, onnx_models_64):\n", "    oinf = OnnxInference(onx)\n", "    diff = max_discrepency_2(x64, model, onx)\n", "    obs64.append(dict(name=model.__class__.__name__, max_diff=diff))\n", "\n", "    \n", "DataFrame(obs64)"]}, {"cell_type": "code", "execution_count": 17, "id": "99107267", "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["DataFrame(obs64).set_index(\"name\").plot(kind=\"bar\").set_title(\"mlprodict + float64\");"]}, {"cell_type": "code", "execution_count": 18, "id": "0b225e1d", "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>float32</th>\n", "      <th>float64</th>\n", "    </tr>\n", "    <tr>\n", "      <th>name</th>\n", "      <th></th>\n", "      <th></th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>RandomForestRegressor</th>\n", "      <td>0.000798</td>\n", "      <td>2.273737e-12</td>\n", "    </tr>\n", "    <tr>\n", "      <th>GradientBoostingRegressor</th>\n", "      <td>0.001440</td>\n", "      <td>9.094947e-13</td>\n", "    </tr>\n", "    <tr>\n", "      <th>HistGradientBoostingRegressor</th>\n", "      <td>0.001082</td>\n", "      <td>9.094947e-13</td>\n", "    </tr>\n", "    <tr>\n", "      <th>LGBMRegressor</th>\n", "      <td>0.001288</td>\n", "      <td>4.686752e-05</td>\n", "    </tr>\n", "    <tr>\n", "      <th>XGBRegressor</th>\n", "      <td>0.000122</td>\n", "      <td>1.562066e-03</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["                                float32       float64\n", "name                                                 \n", "RandomForestRegressor          0.000798  2.273737e-12\n", "GradientBoostingRegressor      0.001440  9.094947e-13\n", "HistGradientBoostingRegressor  0.001082  9.094947e-13\n", "LGBMRegressor                  0.001288  4.686752e-05\n", "XGBRegressor                   0.000122  1.562066e-03"]}, "execution_count": 19, "metadata": {}, "output_type": "execute_result"}], "source": ["df = DataFrame(obs).set_index('name').merge(DataFrame(obs64).set_index('name'),\n", "                                              left_index=True, right_index=True)\n", "df.columns = ['float32', 'float64']\n", "df"]}, {"cell_type": "code", "execution_count": 19, "id": "f54ab505", "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 864x288 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=(12, 4))\n", "df.plot(kind=\"bar\", ax=ax[0]).set_title(\"mlprodict\")\n", "df.plot(kind=\"bar\", ax=ax[1], logy=True).set_title(\"mlprodict\");"]}, {"cell_type": "markdown", "id": "4945651e", "metadata": {}, "source": ["The runtime using double produces lower discrepencies except for *xgboost*. It is probably using float and all the others are using double.\n", "\n", "**Note:** function [to_onnx](http://www.xavierdupre.fr/app/mlprodict/helpsphinx/mlprodict/onnx_conv/convert.html#mlprodict.onnx_conv.convert.to_onnx) automatically registers converters for *lightgbm*, *xgboost* and a dedicated runtime for a new ONNX node [TreeEnsembleRegressorDouble](http://www.xavierdupre.fr/app/mlprodict/helpsphinx/mlprodict/onnxrt/ops_cpu/op_tree_ensemble_regressor.html#mlprodict.onnxrt.ops_cpu.op_tree_ensemble_regressor.TreeEnsembleRegressorDouble). It uses [skl2onnx.to_onnx](https://onnx.ai/sklearn-onnx/api_summary.html#skl2onnx.to_onnx) underneath."]}, {"cell_type": "code", "execution_count": 20, "id": "6436ec98", "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}