MassiveAtoms/benchmark-results
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
529fd8841a
benchmark-results/.ipynb_checkpoints/last_attempt-checkpoint.ipynb

715 lines
2.5 MiB
Plaintext
Raw Normal View History

work done
2020-04-20 11:37:08 +00:00
{
"cells": [
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Importing libs and setting some defaults like the plot size and forcing matplotlib to use seaborn color schemes with softer, more palatable colors "
]
},
work done
2020-04-20 11:37:08 +00:00
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": 1,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"from pandas import DataFrame, Series\n",
"from numpy import nan\n",
"import matplotlib.pyplot as plt\n",
"import statsmodels.api as sm\n",
"import statsmodels.formula.api as smf\n",
"import numpy as np\n",
"plt.rcParams[\"figure.figsize\"] = (24,5)\n",
"import seaborn as sns\n",
"sns.set()\n",
"sns.set(font_scale=1.75)\n"
]
},
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Some default styles that will be used for some functions such as tickmarks, labels, etc"
]
},
work done
2020-04-20 11:37:08 +00:00
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": 2,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [],
"source": [
"cols = [\n",
" \"TEST\",\"MAP\",\"SIZE\", \"TIME\"\n",
"]\n",
"onmodded = pd.read_csv(\"new_repr.csv\", quotechar=\"'\", header=None)\n",
"\n",
"onmodded = onmodded.drop([0],1)\n",
"onmodded.columns= cols\n",
"onmodded = onmodded.drop([0],0)\n",
"onmodded.iloc[:,2:] = onmodded.iloc[:,2:].astype(\"int32\")\n",
"\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"# used for plotter and plotter3, but we can't choose nice looking and distinct enough colors to plot 17 different lines.\n",
"# ultimately abandoned in favor of the default styles from seaborn\n",
work done
2020-04-20 11:37:08 +00:00
"styles = {'absl::flat_hash_map': [\"#0000cc\"], # blue\n",
" \"absl::node_hash_map'\": [\"#3366ff\"],\n",
" 'absl::node_hash_map': [\"#99ccff\"],\n",
"\n",
" 'google::dense_hash_map': [\"#ff0000\"], # reds\n",
" 'google::sparse_hash_map': [\"#ff6666\"],\n",
" 'phmap::parallel_flat_hash_map': [\"#ff0066\"],\n",
"\n",
" 'ska::bytell_hash_map': [\"#009933\"], # greens\n",
" 'ska::flat_hash_map': [\"#33cc33\"],\n",
" 'ska::unordered_map': [\"#99ff66\"],\n",
"\n",
" 'tsl::hopscotch_map': [\"#9900cc\"], # purples\n",
" 'tsl::robin_map': [\"#cc33ff\"],\n",
" 'tsl::sparse_map': [\"#cc99ff\"],\n",
"\n",
" 'robin_hood::unordered_flat_map': [\"#ffcc99\"],\n",
" 'robin_hood::unordered_node_map': [\"#ccff66\"],\n",
"\n",
" 'boost::unordered::unordered_map': [\"#663300\"], # brown\n",
"\n",
" 'emilib::HashMap': [\"#9900cc\"], # purple\n",
"\n",
" # weird orange\n",
" 'phmap::parallel_node_hash_map': [\"#ffcc66\", \"solid\"],\n",
"\n",
" 'std::unordered_map': [\"#000000\", \"solid\"], # black\n",
" }\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"# where to place the x tickmarks and how to label them\n",
work done
2020-04-20 11:37:08 +00:00
"ticks = [50000, 100000, 150000, 200000, 250000, 300000, 350000, 400000, 500000,\n",
"600000, 700000, 800000, 900000, 1000000,\n",
"2000000, 3000000, 4000000, 5000000, 6000000, 7000000, 8000000, 9000000, 10000000,\n",
"15000000, 20000000, 25000000, 30000000, 35000000, 40000000, 45000000, 50000000]\n",
"ticklabels = ['50 K', '100 K',\n",
" '150 K', '200 K', '250 K', '300 K',\n",
" '350 K', '400 K', '0.5 M', '0.6 M',\n",
" '0.7 M', '0.8 M', '0.9 M', '1 M',\n",
" '2 M', '3 M', '4 M', '5 M',\n",
" '6 M', '7 M', '8 M', '9 M',\n",
" '10 M', '15 M', '20 M', '25 M',\n",
" '30 M', '35 M', '40 M', '45 M', '50 M']\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"# convenient way to label the plots for later\n",
work done
2020-04-20 11:37:08 +00:00
"labels = {\n",
" 'int_delete' : [\"mean int deletion time\", \"deletion time (ns)\"],\n",
" 'int_insert' : [\"mean int insertion time\", \"insertion time(ns)\"],\n",
" 'int_nosucc_lookup' : [\"mean int unsucessful lookup time\", \"unsucessful lookup time (ns)\"],\n",
" 'int_succ_lookup' : [\"mean int succesful lookup time\", \"succesful lookup time (ns)\"],\n",
" 'string_delete' : [\"mean string deletion time\", \"deletion time (ns)\"],\n",
" 'string_insert' : [\"mean string insertion time\", \"insertion time(ns)\"], \n",
" 'string_nosucc_lookup' : [\"mean string unsucessful lookup time\", \"unsucessful lookup time (ns)\"],\n",
" 'string_succ_lookup' : [\"mean string succesful lookup time\", \"succesful lookup time (ns)\"]\n",
"}"
]
},
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Function definitions\n",
"Some functions that accept and delete outliers in a range \n",
"A function that removes outliers with the functions mentioned above \n",
"Some helper functions \n",
"Some plotter functions "
]
},
work done
2020-04-20 11:37:08 +00:00
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": 3,
work done
2020-04-20 11:37:08 +00:00
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# outlier testing functions\n",
"def remove_with_modified_z_score(data, treshold=3.5):\n",
" # https://www.itl.nist.gov/div898/handbook/eda/section3/eda35h.htm\n",
" data = data.astype(int)\n",
" stats = data.describe()\n",
" median_absolute_deviation = abs(data - data.median()).median()\n",
" if not median_absolute_deviation:\n",
" return data\n",
" modified_z_scores = abs(0.6745 * (data - data.median()) / median_absolute_deviation)\n",
" cutoff = modified_z_scores <= treshold\n",
" data = data * cutoff\n",
" data = data.replace(0, nan)\n",
" return data\n",
"\n",
"#function that takes one of the outlier testers and data, and removes outliers\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"# originally, we had multiple outlier tests we tried out and this made it convenient to check the differences\n",
"# now it's just the modified_z_score, which we chose\n",
work done
2020-04-20 11:37:08 +00:00
"def remove_outlier(data, function):\n",
" new_data = data.copy(True)\n",
" new_data[\"TIME\"] = new_data[\"TIME\"].astype(int)\n",
" new_data[\"SIZE\"] = new_data[\"SIZE\"].astype(int)\n",
" new_data\n",
" for i in range(4216):\n",
" start = i * 30\n",
" end = start+30\n",
" new_data.loc[start:end, \"TIME\"] = function(data.loc[start:end, \"TIME\"])\n",
" if not i % 420:\n",
" print(i / 42 , \"% done\")\n",
" return new_data\n",
"\n",
"\n",
"# helpers for plot functions\n",
"def sort_maps(test):\n",
" maps = data[data[\"TEST\"]== test][\"MAP\"].unique()\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
" new = [(gr_max.loc[test, i][\"TIME\"], i) for i in maps]\n",
work done
2020-04-20 11:37:08 +00:00
" new.sort()\n",
" new = [i[1] for i in new]\n",
" return new\n",
"\n",
"def divider(df, maplist):\n",
" filters = df['MAP'].isin(maplist)\n",
" return df[filters]\n",
"\n",
"\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"\n",
"\n",
"# These are in no way optimized\n",
"# way too slow for normal use\n",
"# And not particularly reusable\n",
"\n",
work done
2020-04-20 11:37:08 +00:00
"def plotter(test, groups):\n",
" maps = sort_maps(test)\n",
" plot_now = [5,11,16]\n",
"# plot_now = [2,5,8,11,14,16]\n",
"\n",
" for mp in range(0,17):\n",
" map_data = groups.get_group(('int_insert', maps[mp])) \n",
" sns.lineplot(x=\"SIZE\", y=\"TIME\", data=map_data, err_style=\"bars\", color=styles[maps[mp]][0], label=maps[mp], linestyle=\"--\")\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"# sns.lmplot(x=map_data[\"SIZE\"], y=map_data[\"TIME\"], color=styles[maps[mp]][0], label=maps[mp])\n",
work done
2020-04-20 11:37:08 +00:00
" if mp in plot_now:\n",
" plt.xscale(\"log\")\n",
" plt.xticks(ticks, ticklabels)\n",
" plt.set_xticklabels(rotation=45)\n",
" plt.ylabel(labels[test][1])\n",
" plt.legend()\n",
" plt.title(labels[test][0])\n",
" plt.show()\n",
"\n",
"def plotter2(test, data):\n",
" mydata = data[data[\"TEST\"] == test]\n",
" maps = sort_maps(test)\n",
" set1 = divider(mydata, maps[:5])\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
" set3 = divider(mydata, maps[12:])\n",
" # ^ updated this to only do the top 5 and bottom 5\n",
" plot = sns.lineplot(x=\"SIZE\", y=\"TIME\", hue=\"MAP\", data=set1, ci=95) # < updated to use 95% CI\n",
work done
2020-04-20 11:37:08 +00:00
" plt.xscale(\"log\")\n",
" plt.xticks(ticks, ticklabels)\n",
" plot.set_xticklabels(\n",
" plot.get_xticklabels(), \n",
" rotation=55, \n",
" horizontalalignment='center',\n",
" fontweight='light',\n",
" )\n",
" plt.ylabel(labels[test][1])\n",
" plt.legend()\n",
" plt.title(labels[test][0])\n",
" plt.show()\n",
" \n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
" plot = sns.lineplot(x=\"SIZE\", y=\"TIME\", hue=\"MAP\", data=set3, ci=95) # < updated to use 95% CI\n",
work done
2020-04-20 11:37:08 +00:00
" plt.xscale(\"log\")\n",
" plt.xticks(ticks, ticklabels)\n",
" plot.set_xticklabels(\n",
" plot.get_xticklabels(), \n",
" rotation=55, \n",
" horizontalalignment='center',\n",
" fontweight='light',\n",
" )\n",
" plt.ylabel(labels[test][1])\n",
" plt.legend()\n",
" plt.title(labels[test][0])\n",
" plt.show()\n",
"\n",
" \n",
"def plotter3(test, groups):\n",
" maps = sort_maps(test)\n",
" plot_now = [5,11,16]\n",
"# plot_now = [2,5,8,11,14,16]\n",
" for mp in range(0,17):\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
" map_data = groups.get_group(('int_insert', maps[mp])) \n",
" sns.lineplot(x=\"SIZE\", y=\"TIME\", data=map_data, err_style=\"band\", color=styles[maps[mp]][0], label=maps[mp], linestyle=\"--\")\n",
"# sns.regplot(x=\"SIZE\", y=\"TIME\", color=styles[maps[mp]][0],label=maps[mp], data=map_data)\n",
work done
2020-04-20 11:37:08 +00:00
" if mp in plot_now:\n",
" plt.xscale(\"log\")\n",
" plt.xticks(ticks, ticklabels)\n",
" plt.ylabel(labels[test][1])\n",
" plt.legend()\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"# plt.set_xticklabels(rotation=45)\n",
work done
2020-04-20 11:37:08 +00:00
" plt.title(labels[test][0])\n",
" plt.show()\n"
]
},
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Remove the outliers\n",
"* group the data by test and map, in case plotter or plotter3 is used\n",
"* compute means and max of the map"
]
},
work done
2020-04-20 11:37:08 +00:00
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": 4,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0 % done\n",
"10.0 % done\n",
"20.0 % done\n",
"30.0 % done\n",
"40.0 % done\n",
"50.0 % done\n",
"60.0 % done\n",
"70.0 % done\n",
"80.0 % done\n",
"90.0 % done\n",
"100.0 % done\n"
]
}
],
"source": [
"data = remove_outlier(onmodded, remove_with_modified_z_score)\n",
"groups = data.groupby([\"TEST\", \"MAP\"])\n",
"gr_max = groups.max()\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"gr_mean = groups.mean()\n",
"tests = data[\"TEST\"].unique()"
work done
2020-04-20 11:37:08 +00:00
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[0], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 6,
work done
2020-04-20 11:37:08 +00:00
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[1], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 7,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[2], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 8,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[3], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 9,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[4], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 10,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[5], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 11,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[6], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 12,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"image/png": "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
work done
2020-04-20 11:37:08 +00:00
"text/plain": [
"<Figure size 1728x360 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plotter2(tests[7], data)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 13,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"array(['absl::flat_hash_map', 'absl::node_hash_map',\n",
work done
2020-04-20 11:37:08 +00:00
" 'boost::unordered::unordered_map', 'emilib::HashMap',\n",
" 'google::dense_hash_map', 'google::sparse_hash_map',\n",
" 'phmap::parallel_flat_hash_map', 'phmap::parallel_node_hash_map',\n",
" 'robin_hood::unordered_flat_map', 'robin_hood::unordered_node_map',\n",
" 'ska::bytell_hash_map', 'ska::flat_hash_map', 'ska::unordered_map',\n",
" 'std::unordered_map', 'tsl::hopscotch_map', 'tsl::robin_map',\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
" 'tsl::sparse_map'], dtype=object)"
work done
2020-04-20 11:37:08 +00:00
]
},
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 13,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data[\"MAP\"].unique()"
]
},
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Quick way of getting the mean time of each operation and map (for all sizes) \n",
"This number is totally meaningless on it's own, and the absolute values (in ns) should just not be mentioned\n",
"I think it's meaningless to mention that the mean insertion time of a map is 50ns between sizes 50K and 50M.\n",
"It \"loses\" so much info. \n",
"But it is a decent use to rank the maps on. \n",
"Eventhough it is somewhat biased towards maps that perform decently at large sizes. Or in other words, this ranking makes the fact that a function is blazing fast for small sizes matter way less. \n",
"This is due to the following:\n",
"lets say there are 5 measuring points below 1M, and 20 measuring points between 1M and 50M\n",
"when that is averaged, way more points will be >1M, so they will weight more for the mean.\n",
"\n",
"But the graphs are pretty hard to get a quick overview of after a quick glance, so this is my best attempt to create a summary of the relative rankings.\n",
"And I don't have the slightest idea how you would rank them besides a mean value. A max value would be a good idea, except that there's random spiky behavour which have higher values in the middle than at 50M. And it's even less representative of the times as a whole compared to the mean. So we have this. "
]
},
work done
2020-04-20 11:37:08 +00:00
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 14,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11\n",
"9\n",
"13\n",
"4\n",
"6\n",
"17\n",
"12\n",
"14\n",
"7\n",
"1\n",
"8\n",
"3\n",
"10\n",
"15\n",
"5\n",
"2\n",
"16\n"
]
}
],
"source": [
"test = \"string_insert\"\n",
"alpha_maps = gr_mean.loc[test][\"TIME\"].index\n",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"rank = list(gr_mean.loc[test][\"TIME\"].sort_values().index) # sort by mean\n",
"rank = [rank.index(i) for i in alpha_maps] # get the index for each map in alphamaps\n",
work done
2020-04-20 11:37:08 +00:00
"for i in rank:\n",
" print(i + 1)"
]
},
{
"cell_type": "code",
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 15,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"Index(['absl::flat_hash_map', 'absl::node_hash_map',\n",
" 'boost::unordered::unordered_map', 'emilib::HashMap',\n",
" 'google::dense_hash_map', 'google::sparse_hash_map',\n",
" 'phmap::parallel_flat_hash_map', 'phmap::parallel_node_hash_map',\n",
" 'robin_hood::unordered_flat_map', 'robin_hood::unordered_node_map',\n",
" 'ska::bytell_hash_map', 'ska::flat_hash_map', 'ska::unordered_map',\n",
" 'std::unordered_map', 'tsl::hopscotch_map', 'tsl::robin_map',\n",
" 'tsl::sparse_map'],\n",
" dtype='object', name='MAP')"
work done
2020-04-20 11:37:08 +00:00
]
},
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"execution_count": 15,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"output_type": "execute_result"
}
],
updated to do 95% CI instead of 1 std error bars. As if a difference is even noticable
2020-05-12 00:28:43 +00:00
"source": [
"alpha_maps"
]
work done
2020-04-20 11:37:08 +00:00
},
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": null,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
all data
2020-04-20 16:57:40 +00:00
"outputs": [],
"source": []
work done
2020-04-20 11:37:08 +00:00
},
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": null,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
"outputs": [],
all data
2020-04-20 16:57:40 +00:00
"source": []
work done
2020-04-20 11:37:08 +00:00
},
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": null,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
all data
2020-04-20 16:57:40 +00:00
"outputs": [],
"source": []
work done
2020-04-20 11:37:08 +00:00
},
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": null,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
all data
2020-04-20 16:57:40 +00:00
"outputs": [],
work done
2020-04-20 11:37:08 +00:00
"source": []
},
{
"cell_type": "code",
all data
2020-04-20 16:57:40 +00:00
"execution_count": null,
work done
2020-04-20 11:37:08 +00:00
"metadata": {},
all data
2020-04-20 16:57:40 +00:00
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
work done
2020-04-20 11:37:08 +00:00
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"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.8.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Reference in New Issue Copy Permalink