docs/benchmarks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Benchmarks\n",
    "Speed comparisons."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "from spector import indices, matrix, vector\n",
    "\n",
    "\n",
    "def timed(func, *args):\n",
    "    \"\"\"Return elapsed time of function call.\"\"\"\n",
    "    start = time.time()\n",
    "    _ = func(*args)  # noqa\n",
    "    return time.time() - start\n",
    "\n",
    "\n",
    "def dok(size):\n",
    "    return {(i, j): 1.0 for i in range(size) for j in range(size)}\n",
    "\n",
    "\n",
    "def vecs(size):\n",
    "    arr = np.array(range(size))\n",
    "    return matrix((i, vector(arr)) for i in range(size))\n",
    "\n",
    "\n",
    "keys = np.array(range(2**18))\n",
    "values = np.ones(len(keys))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `indices` vs. `set`"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from array\n",
    "timed(indices, keys) / timed(set, keys)"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# to array\n",
    "timed(np.array, indices(keys)) / timed(np.fromiter, keys, keys.dtype, len(keys))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set op\n",
    "timed(indices(keys).__sub__, indices(keys)) / timed(set(keys).__sub__, set(keys))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `vector` vs. `dict`"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from arrays\n",
    "timed(vector, keys, values) / timed(dict, zip(keys, values))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "vec, d = vector(keys, values), dict(zip(keys, values))\n",
    "# keys\n",
    "timed(vec.keys) / timed(np.fromiter, d.keys(), keys.dtype, len(d))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# values\n",
    "timed(vec.values) / timed(np.fromiter, d.values(), values.dtype, len(d))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sum\n",
    "timed(np.sum, vec) / timed(sum, d.values())"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "# matmul\n",
    "timed(vec.__matmul__, vec) / timed(sum, (d[k] * d[k] for k in d))"
   ],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## groupby\n",
    "Matrices rely on an optimized `groupby` implementation which is much faster than [pandas](https://pandas.pydata.org/pandas-docs/stable/groupby.html), especially for integer keys."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "import math\n",
    "import random\n",
    "import pandas as pd\n",
    "from spector import groupby\n",
    "\n",
    "\n",
    "def measure(size, base=10):\n",
    "    buckets = [base**exp for exp in range(round(math.log(size, base)) + 1)]\n",
    "    data = np.array([random.randint(0, size) for _ in range(size)])\n",
    "    rows = []\n",
    "    values = np.arange(len(data))\n",
    "    for num in buckets:\n",
    "        keys = data % num\n",
    "        df = pd.DataFrame({'keys': keys, 'values': values})\n",
    "        rows.append(\n",
    "            {\n",
    "                'hashed': timed(collections.deque, groupby(keys, values), 0),\n",
    "                'sorted': timed(collections.deque, groupby(keys.astype('u8'), values), 0),\n",
    "                'pandas': timed(collections.deque, df.groupby('keys', sort=False)['values'], 0),\n",
    "            }\n",
    "        )\n",
    "    return pd.DataFrame(rows, index=buckets)\n",
    "\n",
    "\n",
    "df = measure(10**5, 10)[['hashed', 'sorted', 'pandas']]\n",
    "df.index.name = 'buckets'\n",
    "df"
   ],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in df.index:\n",
    "    df.loc[i] = df.loc[i] / df.loc[i].min()\n",
    "df"
   ],
   "execution_count": null
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}