{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Pairwise distances with ONNX (pdist)\n", "\n", "Function [pdist](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html) computes pairwise distances between observations in n-dimensional space. It is not that difficult to convert that into *ONNX* when the dimension of the input is always the same. What if not?"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [{"data": {"text/html": ["
\n", ""], "text/plain": [""]}, "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, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["The mlprodict extension is already loaded. To reload it, use:\n", " %reload_ext mlprodict\n"]}], "source": ["%load_ext mlprodict"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Function pdist\n", "\n", "The function [pdist](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html) distances. Let's denote a list of vectors $(X_1, ..., X_n)$, function [pdist](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html) returns the matrix $D=(d_{ij})$ where $d_{ij}=dist(X_i, X_j)=\\lVert X_i - X_j \\rVert^2$."]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0. , 2. , 0.02, 5. ],\n", " [2. , 0. , 1.62, 1. ],\n", " [0.02, 1.62, 0. , 4.42],\n", " [5. , 1. , 4.42, 0. ]])"]}, "execution_count": 4, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy\n", "from scipy.spatial.distance import pdist, squareform\n", "\n", "M = numpy.array([[0, 1],\n", " [1, 2],\n", " [0.1, 1.1],\n", " [2, 2]], dtype=float)\n", "\n", "d1 = squareform(pdist(M, metric='sqeuclidean'))\n", "d1"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The two following functions are implemented to reduce the number of allocations the algorithm requires."]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0. , 2. , 0.02, 5. ],\n", " [2. , 0. , 1.62, 1. ],\n", " [0.02, 1.62, 0. , 4.42],\n", " [5. , 1. , 4.42, 0. ]])"]}, "execution_count": 5, "metadata": {}, "output_type": "execute_result"}], "source": ["def custom_pdist(M):\n", " n = M.shape[0]\n", " res = numpy.zeros((n, n))\n", " buffer = numpy.empty(M.shape)\n", " for i in range(n):\n", " numpy.subtract(M, M[i], out=buffer) # broadcasted substraction\n", " numpy.square(buffer, out=buffer)\n", " res[i, :] = numpy.sum(buffer, axis=1)\n", " return res\n", "\n", "d2 = custom_pdist(M)\n", "d2"]}, {"cell_type": "markdown", "metadata": {}, "source": ["This function computes $n^2$ distances wheres only $\\frac{n(n-1)}{2}$ are necessary since the final matrix is symmetric. Let's change the implementation to reflect that."]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0. , 2. , 0.02, 5. ],\n", " [2. , 0. , 1.62, 1. ],\n", " [0.02, 1.62, 0. , 4.42],\n", " [5. , 1. , 4.42, 0. ]])"]}, "execution_count": 6, "metadata": {}, "output_type": "execute_result"}], "source": ["def custom_pdist_lower(M):\n", " n = M.shape[0]\n", " res = numpy.zeros((n, n))\n", " buffer = numpy.empty((M.shape[0]-1, M.shape[1]))\n", " a = numpy.empty(M.shape[0])\n", " for i in range(1, n):\n", " numpy.subtract(M[:i], M[i], out=buffer[:i]) # broadcasted substraction\n", " numpy.square(buffer[:i], out=buffer[:i])\n", " numpy.sum(buffer[:i], axis=1, out=a[:i])\n", " res[:i, i] = a[:i]\n", " res[i, :i] = a[:i]\n", " return res\n", "\n", "d3 = custom_pdist_lower(M)\n", "d3"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Loop mechanism in ONNX\n", "\n", "Operator [Loop](https://github.com/onnx/onnx/blob/master/docs/Operators.md#Loop) seems appropriate but it is just a loop wheras [Scan](https://github.com/onnx/onnx/blob/master/docs/Operators.md#Scan) holds accumulator. The first graph is what is repeated inside the loop."]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 7, "metadata": {}, "output_type": "execute_result"}], "source": ["from skl2onnx.algebra.onnx_ops import OnnxAdd, OnnxIdentity, OnnxScan\n", "from skl2onnx.common.data_types import FloatTensorType\n", "\n", "initial = numpy.array([0, 0]).astype(numpy.float32).reshape((2,))\n", "x = numpy.array([1, 2, 3, 4, 5, 6]).astype(numpy.float32).reshape((3, 2))\n", "\n", "add_node = OnnxAdd('sum_in', 'next', output_names=['sum_out'], op_version=12)\n", "id_node = OnnxIdentity(add_node, output_names=['scan_out'], op_version=12)\n", "\n", "scan_body = id_node.to_onnx(\n", " {'sum_in': initial, 'next': initial},\n", " outputs=[('sum_out', FloatTensorType()),\n", " ('scan_out', FloatTensorType())])\n", "\n", "# add -l 1 if nothing shows up\n", "%onnxview scan_body"]}, {"cell_type": "markdown", "metadata": {}, "source": ["The operator [Scan](https://github.com/onnx/onnx/blob/master/docs/Operators.md#Scan) repeats this graph a couple of times. *sum_in* is an accumulator, *next* is the iterated row from the input matrix."]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 8, "metadata": {}, "output_type": "execute_result"}], "source": ["node = OnnxScan('initial', 'x', output_names=['y', 'z'],\n", " num_scan_inputs=1, body=scan_body.graph)\n", "\n", "model_def = node.to_onnx(\n", " {'initial': initial, 'x': x},\n", " outputs=[('y', FloatTensorType()),\n", " ('z', FloatTensorType())])\n", "\n", "# add -l 1 if nothing shows up\n", "%onnxview model_def"]}, {"cell_type": "markdown", "metadata": {}, "source": ["All together in the same graph."]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["# add -l 1 if nothing shows up\n", "%onnxview model_def -r 1"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([ 9., 12.], dtype=float32)"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}], "source": ["from mlprodict.onnxrt import OnnxInference\n", "oinf = OnnxInference(model_def)\n", "res = oinf.run({'initial': initial, 'x': x})\n", "res['y']"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[ 1., 2.],\n", " [ 4., 6.],\n", " [ 9., 12.]], dtype=float32)"]}, "execution_count": 11, "metadata": {}, "output_type": "execute_result"}], "source": ["res['z']"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Back to pdist\n", "\n", "[sklearn-onnx](https://github.com/onnx/sklearn-onnx) implements function *pdist* with *ONNX* operators. The parameter ``inputs=[('x', FloatTensorType())`` tels the method ``to_onnx`` that the dimension of the inputs is not fixed and should not be checked."]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 12, "metadata": {}, "output_type": "execute_result"}], "source": ["# from skl2onnx.algebra.complex_functions import squareform_pdist_\n", "\n", "from collections import OrderedDict\n", "from skl2onnx.algebra.onnx_ops import (\n", " OnnxSub, OnnxReduceSumSquare, OnnxSqueeze,\n", " OnnxIdentity, OnnxScan)\n", "from skl2onnx.common.data_types import FloatTensorType\n", "from mlprodict.tools import get_opset_number_from_onnx\n", "\n", "\n", "def squareform_pdist(X, **kwargs):\n", " \"\"\"Returns the ONNX graph which computes\n", " ``squareform(pdist(X, metric='sqeuclidean')``.\"\"\"\n", "\n", " # The subgraph executed at every iteration.\n", " opv = get_opset_number_from_onnx()\n", " diff = OnnxSub('next_in', 'next', output_names=['diff'], op_version=opv)\n", " id_next = OnnxIdentity('next_in', output_names=['next_out'], op_version=opv)\n", " norm = OnnxReduceSumSquare(diff, output_names=['norm'], axes=[1], op_version=opv)\n", " flat = OnnxSqueeze(norm, numpy.array([1], dtype=numpy.int64),\n", " output_names=['scan_out'], op_version=opv)\n", " scan_body = id_next.to_onnx(\n", " OrderedDict([('next_in', FloatTensorType()),\n", " ('next', FloatTensorType())]),\n", " # Size must be empty otherwise onnxruntime fails\n", " # at execution time if it receives a matrix\n", " # with a different shape. With 'None', the same ONNX graph\n", " # can compute pairwise distance for any shape.\n", " outputs=[('next_out', FloatTensorType([None, None])),\n", " ('scan_out', FloatTensorType([None]))],\n", " other_outputs=[flat])\n", "\n", " # The loop.\n", " # 'scan0_{idself}' means the variable name will include\n", " # id(OnnxScan), this is needed if squareform_pdist is used\n", " # twice in the same graph.\n", " node = OnnxScan(X, X, output_names=['scan0_{idself}', 'scan1_{idself}'],\n", " num_scan_inputs=1, body=scan_body.graph, op_version=opv,\n", " **kwargs)\n", " return node[1] \n", "\n", "opv = get_opset_number_from_onnx()\n", "onnx_fct = OnnxIdentity(squareform_pdist('x'), output_names='Y', op_version=opv)\n", "model_def = onnx_fct.to_onnx(inputs=[('x', FloatTensorType())])\n", "\n", "# add -l 1 if nothing shows up\n", "%onnxview model_def"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": ["from collections import OrderedDict\n", "from skl2onnx.algebra.onnx_ops import (\n", " OnnxSub, OnnxReduceSumSquare, OnnxSqueeze,\n", " OnnxIdentity, OnnxScan)\n", "from skl2onnx.common.data_types import FloatTensorType\n", "from mlprodict.tools import get_opset_number_from_onnx\n", "\n", "\n", "def squareform_pdist(X, **kwargs):\n", " # The subgraph executed at every iteration.\n", " opv = get_opset_number_from_onnx()\n", " diff = OnnxSub('next_in', 'next', output_names=['diff'], op_version=opv)\n", " id_next = OnnxIdentity('next_in', output_names=['next_out'], op_version=opv)\n", " norm = OnnxReduceSumSquare(diff, output_names=['norm'], axes=[1], op_version=opv)\n", " flat = OnnxSqueeze(norm, numpy.array([1], dtype=numpy.int64),\n", " output_names=['scan_out'], op_version=opv)\n", " scan_body = id_next.to_onnx(\n", " OrderedDict([('next_in', FloatTensorType()),\n", " ('next', FloatTensorType())]),\n", " outputs=[('next_out', FloatTensorType([None, None])),\n", " ('scan_out', FloatTensorType([None]))],\n", " other_outputs=[flat])\n", "\n", " # The loop.\n", " node = OnnxScan(X, X, output_names=['scan0_{idself}', 'scan1_{idself}'],\n", " num_scan_inputs=1, body=scan_body.graph, op_version=opv,\n", " **kwargs)\n", " return node[1] \n", "\n", "opv = get_opset_number_from_onnx()\n", "onnx_fct = OnnxIdentity(squareform_pdist('x'), output_names='Y', op_version=opv)\n", "model_def = onnx_fct.to_onnx(inputs=[('x', FloatTensorType())])"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Notice the double arrow. Input _x_ is used twice, once as an permanent state involved in broacasted substract, another time to iterator rows. On the other side, the first output of operator *Scan* is a permanent state equal to the input, the second one is an aggregation of results produced at each iteration. Each of those produces a row of a final matrix."]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 14, "metadata": {}, "output_type": "execute_result"}], "source": ["oinf = OnnxInference(model_def)\n", "body = oinf['Sc_Scan', 'body']\n", "\n", "# add -l 1 if nothing shows up\n", "%onnxview body.g"]}, {"cell_type": "markdown", "metadata": {}, "source": ["All together."]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 15, "metadata": {}, "output_type": "execute_result"}], "source": ["# add -l 1 if nothing shows up\n", "%onnxview model_def -r 1"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Let's now execute the graph and compare it with the original graph."]}, {"cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0. , 2. , 0.02, 5. ],\n", " [2. , 0. , 1.62, 1. ],\n", " [0.02, 1.62, 0. , 4.42],\n", " [5. , 1. , 4.42, 0. ]])"]}, "execution_count": 16, "metadata": {}, "output_type": "execute_result"}], "source": ["d1 = squareform(pdist(M, metric='sqeuclidean'))\n", "d1"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"data": {"text/plain": ["array([[0. , 2. , 0.02, 5. ],\n", " [2. , 0. , 1.62, 1. ],\n", " [0.02, 1.62, 0. , 4.42],\n", " [5. , 1. , 4.42, 0. ]])"]}, "execution_count": 17, "metadata": {}, "output_type": "execute_result"}], "source": ["oinf.run({'x': M})['Y']"]}, {"cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["9.31 \u00b5s \u00b1 423 ns per loop (mean \u00b1 std. dev. of 7 runs, 100,000 loops each)\n"]}], "source": ["%timeit squareform(pdist(M, metric='sqeuclidean'))"]}, {"cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["35.1 \u00b5s \u00b1 1.52 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10,000 loops each)\n"]}], "source": ["%timeit custom_pdist(M)"]}, {"cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["34.2 \u00b5s \u00b1 2.18 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10,000 loops each)\n"]}], "source": ["%timeit custom_pdist_lower(M)"]}, {"cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["177 \u00b5s \u00b1 11.3 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10,000 loops each)\n"]}], "source": ["%timeit oinf.run({'x': M})['Y']"]}, {"cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": ["M32 = M.astype(numpy.float32)"]}, {"cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": ["from mlprodict.tools import get_ir_version_from_onnx\n", "model_def.ir_version = get_ir_version_from_onnx()"]}, {"cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["No CUDA runtime is found, using CUDA_HOME='C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.5'\n"]}, {"data": {"text/plain": ["array([[0. , 2. , 0.02000001, 5. ],\n", " [2. , 0. , 1.6199999 , 1. ],\n", " [0.02000001, 1.6199999 , 0. , 4.42 ],\n", " [5. , 1. , 4.42 , 0. ]], dtype=float32)"]}, "execution_count": 24, "metadata": {}, "output_type": "execute_result"}], "source": ["oinfrt = OnnxInference(model_def, runtime=\"onnxruntime1\")\n", "oinfrt.run({'x': M32})['Y']"]}, {"cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["43.1 \u00b5s \u00b1 4.32 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10,000 loops each)\n"]}], "source": ["%timeit oinfrt.run({'x': M32})['Y']"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Benchmark"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"data": {"text/plain": ["{'average': 4.233300000009876e-05,\n", " 'deviation': 2.7235873787981297e-05,\n", " 'min_exec': 1.8629999999575375e-05,\n", " 'max_exec': 0.00010153999999999997,\n", " 'repeat': 10,\n", " 'number': 10,\n", " 'nrows': 4,\n", " 'ncols': 2,\n", " 'name': 'scipy'}"]}, "execution_count": 26, "metadata": {}, "output_type": "execute_result"}], "source": ["from timeit import Timer\n", "\n", "\n", "def measure_time(name, stmt, context, repeat=10, number=10):\n", " tim = Timer(stmt, globals=context)\n", " res = numpy.array(tim.repeat(repeat=repeat, number=number))\n", " res /= number\n", " mean = numpy.mean(res)\n", " dev = numpy.mean(res ** 2)\n", " dev = (dev - mean**2) ** 0.5\n", " return dict(average=mean, deviation=dev, min_exec=numpy.min(res),\n", " max_exec=numpy.max(res), repeat=repeat, number=number,\n", " nrows=context['M'].shape[0], ncols=context['M'].shape[1],\n", " name=name)\n", "\n", "measure_time(\"scipy\", \"squareform(pdist(M, metric='sqeuclidean'))\",\n", " context={'squareform': squareform, 'M': M,\n", " 'pdist': pdist})"]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["feat=100 n=400: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 26/26 [01:20<00:00, 3.10s/it]\n"]}, {"data": {"text/html": ["\n", "\n", "
\n", " \n", " \n", " \n", " average \n", " deviation \n", " min_exec \n", " max_exec \n", " repeat \n", " number \n", " nrows \n", " ncols \n", " name \n", " dimres \n", " \n", " \n", " \n", " \n", " 0 \n", " 0.000015 \n", " 0.000005 \n", " 0.000010 \n", " 0.000025 \n", " 10 \n", " 10 \n", " 5 \n", " 5 \n", " scipy \n", " 5 \n", " \n", " \n", " 1 \n", " 0.000106 \n", " 0.000023 \n", " 0.000065 \n", " 0.000138 \n", " 10 \n", " 10 \n", " 5 \n", " 5 \n", " numpy \n", " 5 \n", " \n", " \n", " 2 \n", " 0.000053 \n", " 0.000005 \n", " 0.000048 \n", " 0.000064 \n", " 10 \n", " 10 \n", " 5 \n", " 5 \n", " numpy-lower \n", " 5 \n", " \n", " \n", " 3 \n", " 0.000240 \n", " 0.000017 \n", " 0.000219 \n", " 0.000273 \n", " 10 \n", " 10 \n", " 5 \n", " 5 \n", " onnx-py \n", " 5 \n", " \n", " \n", " 4 \n", " 0.000053 \n", " 0.000008 \n", " 0.000046 \n", " 0.000072 \n", " 10 \n", " 10 \n", " 5 \n", " 5 \n", " onnx-rt \n", " 5 \n", " \n", " \n", "
\n", "
"], "text/plain": [" average deviation min_exec max_exec repeat number nrows ncols \\\n", "0 0.000015 0.000005 0.000010 0.000025 10 10 5 5 \n", "1 0.000106 0.000023 0.000065 0.000138 10 10 5 5 \n", "2 0.000053 0.000005 0.000048 0.000064 10 10 5 5 \n", "3 0.000240 0.000017 0.000219 0.000273 10 10 5 5 \n", "4 0.000053 0.000008 0.000046 0.000072 10 10 5 5 \n", "\n", " name dimres \n", "0 scipy 5 \n", "1 numpy 5 \n", "2 numpy-lower 5 \n", "3 onnx-py 5 \n", "4 onnx-rt 5 "]}, "execution_count": 27, "metadata": {}, "output_type": "execute_result"}], "source": ["from tqdm import trange\n", "\n", "def generator():\n", " for feat in [5, 10, 50, 100]:\n", " for n in [5, 10, 20, 50, 100, 400, 1000]:\n", " if n <= 500 or feat <= 10:\n", " yield feat, n\n", " \n", "all_values = list(generator())\n", "\n", "rows = []\n", "\n", "with trange(len(all_values)) as t:\n", " for i in t: \n", " feat, n = all_values[i]\n", " t.set_description(\"feat=%d n=%d\" % (feat, n))\n", " M = numpy.random.rand(n, feat)\n", "\n", " context = {'squareform': squareform, 'M': M, 'pdist': pdist}\n", " res = measure_time(\"scipy\", \"squareform(pdist(M, metric='sqeuclidean'))\", context=context)\n", " res['dimres'] = squareform(pdist(M, metric='sqeuclidean')).shape[0]\n", " rows.append(res)\n", "\n", " context = {'M': M, 'custom_pdist': custom_pdist}\n", " res = measure_time(\"numpy\", \"custom_pdist(M)\", context=context)\n", " res['dimres'] = custom_pdist(M).shape[0]\n", " rows.append(res)\n", "\n", " context = {'M': M, 'custom_pdist_lower': custom_pdist_lower}\n", " res = measure_time(\"numpy-lower\", \"custom_pdist_lower(M)\", context=context)\n", " res['dimres'] = custom_pdist_lower(M).shape[0]\n", " rows.append(res)\n", "\n", " context = {'oinf': oinf, 'M': M}\n", " res = measure_time(\"onnx-py\", \"oinf.run({'x': M})['Y']\", context=context)\n", " res['dimres'] = oinf.run({'x': M})['Y'].shape[0]\n", " rows.append(res)\n", "\n", " M32 = M.astype(numpy.float32)\n", " context = {'oinfrt': oinfrt, 'M': M32}\n", " res = measure_time(\"onnx-rt\", \"oinfrt.run({'x': M})['Y']\", context=context)\n", " res['dimres'] = oinfrt.run({'x': M32})['Y'].shape[0]\n", " rows.append(res)\n", "\n", " \n", "from pandas import DataFrame\n", "df = DataFrame(rows)\n", "df.head()"]}, {"cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", "\n", "
\n", " \n", " \n", " \n", " nrows \n", " 5 \n", " 10 \n", " 20 \n", " 50 \n", " 100 \n", " \n", " \n", " ncols \n", " name \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 5 \n", " numpy \n", " 0.000106 \n", " 0.000108 \n", " 0.000193 \n", " 0.000464 \n", " 0.001121 \n", " \n", " \n", " numpy-lower \n", " 0.000053 \n", " 0.000099 \n", " 0.000225 \n", " 0.000520 \n", " 0.001190 \n", " \n", " \n", " onnx-py \n", " 0.000240 \n", " 0.000407 \n", " 0.000797 \n", " 0.002581 \n", " 0.003790 \n", " \n", " \n", " onnx-rt \n", " 0.000053 \n", " 0.000071 \n", " 0.000118 \n", " 0.000306 \n", " 0.000766 \n", " \n", " \n", " scipy \n", " 0.000015 \n", " 0.000011 \n", " 0.000014 \n", " 0.000020 \n", " 0.000044 \n", " \n", " \n", " 10 \n", " numpy \n", " 0.000067 \n", " 0.000094 \n", " 0.000194 \n", " 0.000569 \n", " 0.001441 \n", " \n", " \n", " numpy-lower \n", " 0.000044 \n", " 0.000093 \n", " 0.000189 \n", " 0.000591 \n", " 0.001209 \n", " \n", " \n", " onnx-py \n", " 0.000226 \n", " 0.000379 \n", " 0.000751 \n", " 0.001945 \n", " 0.004731 \n", " \n", " \n", " onnx-rt \n", " 0.000048 \n", " 0.000072 \n", " 0.000144 \n", " 0.000329 \n", " 0.000995 \n", " \n", " \n", " scipy \n", " 0.000013 \n", " 0.000013 \n", " 0.000016 \n", " 0.000023 \n", " 0.000071 \n", " \n", " \n", " 50 \n", " numpy \n", " 0.000084 \n", " 0.000114 \n", " 0.000257 \n", " 0.000833 \n", " 0.002031 \n", " \n", " \n", " numpy-lower \n", " 0.000069 \n", " 0.000114 \n", " 0.000272 \n", " 0.000757 \n", " 0.001749 \n", " \n", " \n", " onnx-py \n", " 0.000323 \n", " 0.000480 \n", " 0.001214 \n", " 0.002648 \n", " 0.006138 \n", " \n", " \n", " onnx-rt \n", " 0.000059 \n", " 0.000091 \n", " 0.000179 \n", " 0.000554 \n", " 0.001614 \n", " \n", " \n", " scipy \n", " 0.000016 \n", " 0.000016 \n", " 0.000027 \n", " 0.000088 \n", " 0.000200 \n", " \n", " \n", " 100 \n", " numpy \n", " 0.000068 \n", " 0.000098 \n", " 0.000262 \n", " 0.000759 \n", " 0.002712 \n", " \n", " \n", " numpy-lower \n", " 0.000061 \n", " 0.000108 \n", " 0.000338 \n", " 0.000666 \n", " 0.002270 \n", " \n", " \n", " onnx-py \n", " 0.000261 \n", " 0.000451 \n", " 0.001082 \n", " 0.002272 \n", " 0.007142 \n", " \n", " \n", " onnx-rt \n", " 0.000050 \n", " 0.000084 \n", " 0.000166 \n", " 0.000672 \n", " 0.002097 \n", " \n", " \n", " scipy \n", " 0.000017 \n", " 0.000019 \n", " 0.000025 \n", " 0.000089 \n", " 0.000327 \n", " \n", " \n", "
\n", "
"], "text/plain": ["nrows 5 10 20 50 100\n", "ncols name \n", "5 numpy 0.000106 0.000108 0.000193 0.000464 0.001121\n", " numpy-lower 0.000053 0.000099 0.000225 0.000520 0.001190\n", " onnx-py 0.000240 0.000407 0.000797 0.002581 0.003790\n", " onnx-rt 0.000053 0.000071 0.000118 0.000306 0.000766\n", " scipy 0.000015 0.000011 0.000014 0.000020 0.000044\n", "10 numpy 0.000067 0.000094 0.000194 0.000569 0.001441\n", " numpy-lower 0.000044 0.000093 0.000189 0.000591 0.001209\n", " onnx-py 0.000226 0.000379 0.000751 0.001945 0.004731\n", " onnx-rt 0.000048 0.000072 0.000144 0.000329 0.000995\n", " scipy 0.000013 0.000013 0.000016 0.000023 0.000071\n", "50 numpy 0.000084 0.000114 0.000257 0.000833 0.002031\n", " numpy-lower 0.000069 0.000114 0.000272 0.000757 0.001749\n", " onnx-py 0.000323 0.000480 0.001214 0.002648 0.006138\n", " onnx-rt 0.000059 0.000091 0.000179 0.000554 0.001614\n", " scipy 0.000016 0.000016 0.000027 0.000088 0.000200\n", "100 numpy 0.000068 0.000098 0.000262 0.000759 0.002712\n", " numpy-lower 0.000061 0.000108 0.000338 0.000666 0.002270\n", " onnx-py 0.000261 0.000451 0.001082 0.002272 0.007142\n", " onnx-rt 0.000050 0.000084 0.000166 0.000672 0.002097\n", " scipy 0.000017 0.000019 0.000025 0.000089 0.000327"]}, "execution_count": 28, "metadata": {}, "output_type": "execute_result"}], "source": ["from pandas import pivot_table\n", "piv = pivot_table(df, index=[\"nrows\"], columns= ['ncols', 'name'], values='average')\n", "piv.head().T"]}, {"cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": ["%matplotlib inline"]}, {"cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": [""]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots(1, 3, figsize=(14, 3))\n", "for i, ncol in enumerate([10, 50, 100]):\n", " piv = df[df.ncols==ncol].pivot(\"nrows\", \"name\", \"average\")\n", " piv.plot(ax=ax[i], logy=True, logx=True)\n", " ax[i].set_title(\"ncol=%d\" % ncol)\n", "ax;"]}, {"cell_type": "markdown", "metadata": {}, "source": ["Curves are not linear and rather difficult to interpret. The algorithm *numpy-lower* and *scipy* should be close as the cost of both algorithm are similar. However, *scipy* reduces the number of trips between C and python. The C implementation of the distance is here:\n", "[sqeuclidean_distance_double](https://github.com/scipy/scipy/blob/master/scipy/spatial/src/distance_impl.h#L50). The final cost is a combination of computation, multithreading, allocations..."]}, {"cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": ["from pyquickhelper.pycode.profiling import profile\n", "M = numpy.random.rand(100, 10)\n", "\n", "pr1, df1 = profile(lambda: [squareform(pdist(M, metric='sqeuclidean')) for i in range(0, 1000)],\n", " as_df=True)\n", "pr2, df2 = profile(lambda: [custom_pdist_lower(M) for i in range(0, 1000)], as_df=True)"]}, {"cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": [""]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["ax = df1[['namefct', 'cum_tall']].head(n=15).set_index('namefct').plot(\n", " kind='bar', figsize=(8, 3), rot=30)\n", "ax.set_title(\"scipy\")\n", "for la in ax.get_xticklabels():\n", " la.set_horizontalalignment('right')"]}, {"cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": [""]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["ax = df2[['namefct', 'cum_tall']].head(n=15).set_index('namefct').plot(\n", " kind='bar', figsize=(8, 3), rot=30)\n", "ax.set_title(\"numpy-lower\")\n", "for la in ax.get_xticklabels():\n", " la.set_horizontalalignment('right'); "]}, {"cell_type": "markdown", "metadata": {}, "source": ["[Universal function](https://docs.scipy.org/doc/numpy/reference/ufuncs.html) do not seem to be very efficient in our case. The last graph shows time ratio between implementations of *pdist* and the baseline *scipy*."]}, {"cell_type": "code", "execution_count": 33, "metadata": {"scrolled": true}, "outputs": [{"data": {"image/png": "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\n", "text/plain": [""]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["fig, ax = plt.subplots(1, 3, figsize=(14, 3))\n", "for i, ncol in enumerate([10, 50, 100]):\n", " piv = df[df.ncols==ncol].pivot(\"nrows\", \"name\", \"average\")\n", " piv['numpy / scipy'] = piv['numpy'] / piv['scipy']\n", " piv['numpy-lower / scipy'] = piv['numpy-lower'] / piv['scipy']\n", " piv['onnx-py / scipy'] = piv['onnx-py'] / piv['scipy']\n", " piv['onnx-rt / scipy'] = piv['onnx-rt'] / piv['scipy']\n", " piv = piv[['numpy / scipy', 'numpy-lower / scipy', \n", " 'onnx-py / scipy', 'onnx-rt / scipy']]\n", " piv.plot(ax=ax[i], logy=True, logx=True)\n", " ax[i].plot([0, max(piv.index)], [1, 1], '--', color='black')\n", " ax[i].plot([0, max(piv.index)], [10, 10], '--', color='black')\n", " ax[i].set_title(\"ncol=%d\" % ncol)\n", "ax;"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Test with a new operator CDist\n", "\n", "The final question is: *should we introduce a new operator into [ONNX specifications](https://github.com/onnx/onnx/blob/master/docs/Operators.md)?* The function [pdist](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html) is not necessarily often used for a big number of observations as the square matrix it produces will even bigger. It seems reasonable. We showed that a python runtime based on *numpy* would not help, the implementation must be done in C++ or directly used the *scipy* version. The experiment was done with a [GaussianProcessRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessRegressor.html). The following section tests with and without a new operator ``CDist`` reusing *scipy* implementation."]}, {"cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 35, "metadata": {}, "output_type": "execute_result"}], "source": ["import numpy\n", "from sklearn.datasets import load_iris\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.gaussian_process import GaussianProcessRegressor\n", "from sklearn.gaussian_process.kernels import ExpSineSquared\n", "from mlprodict.onnx_conv import to_onnx\n", "from mlprodict.onnxrt import OnnxInference\n", "\n", "\n", "iris = load_iris()\n", "X, y = iris.data, iris.target\n", "X_train, X_test, y_train, __ = train_test_split(X, y, random_state=12)\n", "clr = GaussianProcessRegressor(ExpSineSquared(), alpha=20.)\n", "clr.fit(X_train, y_train)\n", "\n", "model_def = to_onnx(clr, X_train)\n", "\n", "%onnxview model_def -r 1"]}, {"cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [{"data": {"text/html": ["\n", ""], "text/plain": [""]}, "execution_count": 36, "metadata": {}, "output_type": "execute_result"}], "source": ["model_def_cdist = to_onnx(clr, X_train,\n", " options={GaussianProcessRegressor: {'optim': 'cdist'}})\n", "%onnxview model_def_cdist"]}, {"cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": ["oinf = OnnxInference(model_def)\n", "oinf_cdist = OnnxInference(model_def_cdist)"]}, {"cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["4.24 ms \u00b1 274 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n"]}], "source": ["%timeit oinf.run({'X': X_test})"]}, {"cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["414 \u00b5s \u00b1 15 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1,000 loops each)\n"]}], "source": ["%timeit oinf_cdist.run({'X': X_test})"]}, {"cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": ["oinfrt = OnnxInference(model_def, runtime=\"onnxruntime1\")\n", "oinfrt_cdist = OnnxInference(model_def_cdist)"]}, {"cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["345 \u00b5s \u00b1 26.8 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1,000 loops each)\n"]}], "source": ["%timeit oinfrt_cdist.run({'X': X_test})"]}, {"cell_type": "markdown", "metadata": {}, "source": ["It is 10 times faster for this dataset so it is worth it. For bigger datasets, we should expect a lower gain but still significant."]}, {"cell_type": "code", "execution_count": 41, "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": 2}