diff --git a/jastadd-mquat-benchmark/results/jastadd-mquat-plots.ipynb b/jastadd-mquat-benchmark/results/jastadd-mquat-plots.ipynb deleted file mode 100644 index ed4d32568649267edb91c91662050832377a0fb4..0000000000000000000000000000000000000000 --- a/jastadd-mquat-benchmark/results/jastadd-mquat-plots.ipynb +++ /dev/null @@ -1,461 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: numpy in /home/rschoene/.local/lib/python3.6/site-packages\r\n", - "Requirement already satisfied: pandas in /home/rschoene/.local/lib/python3.6/site-packages\r\n", - "Requirement already satisfied: scipy in /home/rschoene/.local/lib/python3.6/site-packages\r\n", - "Requirement already satisfied: matplotlib in /home/rschoene/.local/lib/python3.6/site-packages\r\n", - "Requirement already satisfied: python-dateutil>=2 in /home/rschoene/.local/lib/python3.6/site-packages (from pandas)\r\n", - "Requirement already satisfied: pytz>=2011k in /usr/lib/python3.6/site-packages (from pandas)\r\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/lib/python3.6/site-packages (from matplotlib)\r\n", - "Requirement already satisfied: cycler>=0.10 in /home/rschoene/.local/lib/python3.6/site-packages (from matplotlib)\r\n", - "Requirement already satisfied: six>=1.10 in /usr/lib/python3.6/site-packages (from matplotlib)\r\n" - ] - } - ], - "source": [ - "!pip3 install --user numpy pandas scipy matplotlib\n", - "import pandas as pd\n", - "import numpy as np\n", - "import scipy as sp\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import colors as mcolors\n", - "# import plotly.plotly as py\n", - "# import plotly.figure_factory as ff\n", - "# from plotly.graph_objs import *" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['ILP (Direct)', 'ILP (External)', 'Simple']" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def toLabel(name):\n", - " if '-' in name:\n", - " tokens = name.split('-')\n", - " return '{} ({})'.format(tokens[0].upper(), tokens[1].title())\n", - " else:\n", - " return name.title()\n", - "\n", - "[toLabel(n) for n in ['ilp-direct', 'ilp-external', 'simple']]" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "bar_width = 0.2\n", - "solver_names = ['ilp-direct', 'ilp-external', 'simple', 'mh-naive']\n", - "patterns = ['❌', '❌', '✔', '➖']\n", - "colors = [c[4:] for c in (sorted(mcolors.TABLEAU_COLORS.keys())) if 'dark'+c[4:] in mcolors.CSS4_COLORS]\n", - "colors.reverse()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def load(name, show_head=False):\n", - " data = pd.read_csv(name)\n", - " data['name'] = data.comp.astype(str).str.cat(\n", - " [data.impl.astype(str),\n", - " data.conf.astype(str),\n", - " data.req.astype(str)], sep='-')\n", - " if show_head:\n", - " data.head()\n", - " return data" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def add_gen_and_solve(ax, index, i, solver_name, df, suffix, printStatus=True):\n", - " pattern_index = 2 * df.get(solver_name + 'Valid' + suffix) + df.get(solver_name + 'TimeOut' + suffix)\n", - " genTimes = df.get(solver_name + 'Gen' + suffix)\n", - " if genTimes is not None:\n", - " ax.bar(index + i * bar_width, genTimes, bar_width,\n", - " #label=toLabel(solver_name) + \"[GEN]\",\n", - " color='dark' + colors[i])\n", - " solvTimes = df.get(solver_name + 'Solved' + suffix)\n", - " solvBars = None\n", - " if solvTimes is not None:\n", - " solvBars = ax.bar(index + i * bar_width, solvTimes, bar_width,\n", - " label=toLabel(solver_name),\n", - " bottom=genTimes,\n", - " color=colors[i])\n", - " if printStatus and solvBars is not None:\n", - " for rect, pi in zip(solvBars, pattern_index):\n", - " height = rect.get_height()\n", - " #print(rect.get_y(), height)\n", - " ax.text(rect.get_x() + rect.get_width() / 2, max(5, rect.get_y() + height),\n", - " patterns[pi], fontname='symbola', \n", - " ha='center', va='bottom', color=colors[i])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "def create_single(name, suffix='Hard'):\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(111)\n", - " data = load(name)\n", - " index = np.arange(len(data.name))\n", - " for i, solver_name in enumerate(solver_names):\n", - " add_gen_and_solve(ax, index, i, solver_name, data, suffix, False)\n", - "\n", - " plt.xticks(rotation=90)\n", - " plt.title(\"Solving time for hard problem\")\n", - " plt.xlabel('Comp-Impl-Config-Request')\n", - " plt.ylabel('Solving time [ms]')\n", - " plt.yscale(\"log\")\n", - "\n", - " plt.xticks(index + bar_width / len(solver_names), data.name.astype(str))\n", - " plt.legend()\n", - " plt.tight_layout()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<matplotlib.figure.Figure at 0x7f5bf56050b8>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "create_single('incremental/handcrafted-benchmark-1.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def make_plot(name, df, ax, solver_names=solver_names, suffix='Hard'):\n", - " index = np.arange(len(df.name))\n", - " for i, solver_name in enumerate(solver_names):\n", - " add_gen_and_solve(ax, index, i, solver_name, df, suffix)\n", - " ax.set_title(name)\n", - "\n", - " plt.sca(ax)\n", - " plt.yscale(\"log\")\n", - " plt.xticks(rotation=90)\n", - " plt.xticks(index + bar_width / len(solver_names), list(df.name))" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "def create_row(name):\n", - " data = load(name)\n", - " groupByReq = data.groupby('req')\n", - " nrDifferentRequests = len(groupByReq)\n", - " print (nrDifferentRequests)\n", - "\n", - " fig, axs = plt.subplots(1, nrDifferentRequests, sharey=True)\n", - " plt.suptitle(\"Solving time for hard problem\", fontsize=16)\n", - " #fig.autofmt_xdate()\n", - " #print (axs)\n", - " for (name, df), ax in zip(groupByReq, axs.flatten()):\n", - " #print (df['ilp-externalSolvedHard'])\n", - " make_plot('req=' + str(name), df, ax, ['ilp-external'])\n", - "\n", - " ## Create shared axes title\n", - " fig.add_subplot(111, frameon=False)\n", - " # hide tick and tick label of the big axes\n", - " plt.tick_params(labelcolor='none', top='off', bottom='off', left='off', right='off')\n", - " plt.grid(False)\n", - " plt.xlabel(\"Comp-Impl-Config-Request\", labelpad=50)\n", - " plt.ylabel(\"Solving time [ms]\")\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<matplotlib.figure.Figure at 0x7f5bf32e3898>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "create_row('incremental/handcrafted-benchmark-1.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def make_plot_in_grid(name, df, ax, suffix, solver_names=solver_names):\n", - " index = np.arange(len(df.name))\n", - " for i, solver_name in enumerate(solver_names):\n", - " add_gen_and_solve(ax, index, i, solver_name, df, suffix)\n", - " ax.set_title(name, visible=name is not None)\n", - "\n", - " plt.sca(ax)\n", - " plt.yscale(\"log\")\n", - " plt.xticks(index + bar_width / len(solver_names), list(df.conf))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def create_grid_plot(name, suffix='Hard'):\n", - " data = load(name)\n", - " groupByResRat = data.groupby('res')\n", - " nrDifferentRatios = len(groupByResRat)\n", - " nrDifferentRequests = len(data.req.unique())\n", - " print (\"nrDifferentRequests:\", nrDifferentRequests, \"nrDifferentRatios:\", nrDifferentRatios)\n", - "\n", - " fig, axs = plt.subplots(nrDifferentRatios, nrDifferentRequests, sharey=True, figsize=(12, 12))\n", - " plt.suptitle(\"Solving time for hard problem\", fontsize=16)\n", - "\n", - " #print (axs)\n", - " firstResRatio = True\n", - " for (resRatio, df), axs_res_ratio in zip(groupByResRat, axs):\n", - " lastAx = axs_res_ratio[-1]\n", - " lastAx.set_ylabel('rr=' + str(resRatio), rotation=0)\n", - " #lastAx.yaxis.set_label_position(\"right\")\n", - " lastAx.yaxis.set_label_coords(1.3,0.5)\n", - " #print (resRatio)\n", - " for (reqNumber, df_inner), ax in zip(df.groupby('req'), axs_res_ratio):\n", - " name = 'req=' + str(reqNumber) if firstResRatio else None\n", - " #print (name)\n", - " make_plot_in_grid(name, df_inner, ax, suffix, solver_names=['ilp-external', 'ilp-direct', 'simple'])\n", - " firstResRatio = False\n", - "\n", - " ## general settings\n", - " ## create another subplot for the big axes (solving time, configurations)\n", - " fig.add_subplot(111, frameon=False)\n", - " ## hide tick and tick label of the big axes\n", - " plt.tick_params(labelcolor='none', top='off', bottom='off', left='off', right='off')\n", - " plt.grid(False)\n", - " plt.xlabel(\"Configurations\", labelpad=0)\n", - " plt.ylabel(\"Solving time [ms]\", labelpad=20)\n", - "\n", - " ## tight layout make title worse at the moment\n", - " #plt.tight_layout()\n", - " #plt.subplots_adjust(top=0.85, left=0.85)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nrDifferentRequests: 4 nrDifferentRatios: 2\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<matplotlib.figure.Figure at 0x7f5bf2eb2748>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "create_grid_plot('incremental/handcrafted-benchmark-1.csv')" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "create_grid_plot('incremental/benchmark-2018-01-23-12-33-59.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nrDifferentRequests: 5 nrDifferentRatios: 8\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<matplotlib.figure.Figure at 0x7f5bf301dc88>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "create_grid_plot('http://141.76.65.44:8080/jastadd-mquat-benchmark/results/basic/benchmark-2018-01-24-16-18-58.csv', suffix='')" - ] - }, - { - "cell_type": "raw", - "metadata": { - "scrolled": false - }, - "source": [ - "hpattern = ['x', 'x', '', '/']\n", - "\n", - "def create_single_hatched(name, solver_names=solver_names, fromIncremental=True):\n", - " data = load(name)\n", - " suffix = 'Hard' if fromIncremental else ''\n", - " index = np.arange(len(data.name))\n", - " for i, solver_name in enumerate(solver_names):\n", - " hpattern_index = 2 * data.get(solver_name + 'Valid' + suffix) + data.get(solver_name + 'TimeOut' + suffix)\n", - " print (solver_name, suffix, [hpattern[pi] for pi in hpattern_index])\n", - " genTimes = data.get(solver_name + 'Gen' + suffix)\n", - " if genTimes is not None:\n", - " plt.bar(index + i * bar_width, genTimes, bar_width,\n", - " label=toLabel(solver_name) + \"[GEN]\",\n", - " color='dark' + colors[i],\n", - " hatch='/',\n", - " #edgecolor='black'\n", - " )\n", - " solvTimes = data.get(solver_name + 'Solved' + suffix)\n", - " if solvTimes is not None:\n", - " plt.bar(index + i * bar_width, solvTimes, bar_width,\n", - " label=toLabel(solver_name),\n", - " bottom=genTimes,\n", - " color=colors[i],\n", - " hatch='/',\n", - " )\n", - "\n", - " plt.xticks(rotation=90)\n", - " plt.title(\"Solving time for hard problem\")\n", - " plt.xlabel('Comp-Impl-Config-Request')\n", - " plt.ylabel('Solving time [ms]')\n", - " plt.yscale(\"log\")\n", - "\n", - " plt.xticks(index + bar_width / len(solver_names), data.name.astype(str))\n", - " plt.legend()\n", - " plt.tight_layout()\n", - " plt.show()" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "create_single_hatched('incremental/handcrafted-benchmark-hatched.csv',\n", - " solver_names=['ilp-external', 'ilp-direct', 'simple'],\n", - " fromIncremental=False)" - ] - } - ], - "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.6.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/jastadd-mquat-benchmark/results/plot.py b/jastadd-mquat-benchmark/results/plot.py index d80f654c11a5fd378dd1cca045b3ce71acb00feb..994faec9216c7ede47509e88cdafb328c6c39285 100644 --- a/jastadd-mquat-benchmark/results/plot.py +++ b/jastadd-mquat-benchmark/results/plot.py @@ -39,18 +39,12 @@ def load_scenario_file(name, show_head=False): def plot_range(names, labels, ax): - # constants - # colors = plt.get_cmap("rainbow") - # colors = list(mcolors.to_rgba_array(color)) + # constants N = len(solver_names) width = 0.05 ind = np.arange(N) - barpos = [] - for i in range(len(names)): - barpos += list((ind + i * (N + 0.5)) * width) - labelpos = [] for i in range(len(names)): labelpos += [(0.5 + i * (N + 0.5)) * width] @@ -64,7 +58,7 @@ def plot_range(names, labels, ax): rect = ax.bar((ind + i * (N + 0.5)) * width, means, width=width, color=colors) for r, isValid, color in zip(rect, data.Valid, colors): ax.text(r.get_x() + r.get_width() / 2, - r.get_height() * 1.4, + r.get_height() * 1.5, patterns[isValid], # the text fontname='symbola', fontsize=16, ha='center', va='bottom', color='black') @@ -74,13 +68,13 @@ def plot_range(names, labels, ax): '%d' % int(r.get_height()), fontsize=8, ha='center', va='bottom', color='black') - - ax.set_xticks(labelpos) ax.set_xticklabels(labels) - # ax.legend(rect, [to_label(n) for n in solver_names]) + ax.set_yticks([1, 1000, 1000000]) + return rect + def create_grid(): variants = [2, 4] @@ -89,49 +83,60 @@ def create_grid(): resources = [15, 30] y_dimension = (requests, "Requests") - x_dimension = (variants, "Implementation\nVariants") - inner_dimension = (depth, "Depth") + x_dimension = (depth, "Depth") + inner_dimension = (variants, "Variants") fixed_dimension = (resources, "Resources") - fixed_dimension_fix = 0 pos_map = { - "Implementation\nVariants": 0, + "Variants": 0, "Requests": 1, "Depth": 2, "Resources": 3 } - - - fig, axs = plt.subplots(len(y_dimension[0]), len(x_dimension[0]), figsize=(12, 12), subplot_kw=dict(yscale="log")) - - for y, y_pos in zip(y_dimension[0], range(len(y_dimension[0]))): - for x, x_pos in zip(x_dimension[0], range(len(x_dimension[0]))): - parameters = [] - labels = [] - for inner in inner_dimension[0]: - new_parameters = [0,0,0,0] - new_parameters[pos_map[x_dimension[1]]] = x - new_parameters[pos_map[y_dimension[1]]] = y - new_parameters[pos_map[inner_dimension[1]]] = inner - new_parameters[pos_map[fixed_dimension[1]]] = fixed_dimension[0][fixed_dimension_fix] - parameters += [new_parameters] - labels += [inner_dimension[1] + ' = %d' % inner] - print(parameters) - plot_range(['size_v%d_q%d_d%d_r%d.csv' % (p[0], p[1], p[2], p[3]) for p in parameters], [label for label in labels], - axs[y_pos, x_pos]) - - for i in range(len(y_dimension[0])): - axs[i][-1].set_ylabel(y_dimension[1] + ' = ' + str(y_dimension[0][i]), rotation=0) - axs[i][-1].yaxis.set_label_coords(1.2, 0.5) - - for i in range(len(x_dimension[0])): - axs[0][i].set_xlabel(x_dimension[1] + ' = ' + str(x_dimension[0][i]), rotation=0) - axs[0][i].xaxis.set_label_coords(0.5, 1.05) - - fig.patch.set_facecolor('w') - - plt.show() + for fixed_pos in fixed_dimension[0]: + fig, axs = plt.subplots(len(y_dimension[0]), len(x_dimension[0]), figsize=(10, 10), subplot_kw=dict(yscale="log"), gridspec_kw={}) + for y, y_pos in zip(y_dimension[0], range(len(y_dimension[0]))): + for x, x_pos in zip(x_dimension[0], range(len(x_dimension[0]))): + parameters = [] + labels = [] + for inner in inner_dimension[0]: + new_parameters = [0,0,0,0] + new_parameters[pos_map[x_dimension[1]]] = x + new_parameters[pos_map[y_dimension[1]]] = y + new_parameters[pos_map[inner_dimension[1]]] = inner + new_parameters[pos_map[fixed_dimension[1]]] = fixed_pos + parameters += [new_parameters] + labels += [inner_dimension[1] + ' = %d' % inner] + rect = plot_range(['size_v%d_q%d_d%d_r%d.csv' % (p[0], p[1], p[2], p[3]) for p in parameters], [label for label in labels], axs[y_pos, x_pos]) + if x_pos == 0 and y_pos == 0: + axs[y_pos, x_pos].set_ylabel("X",fontsize=70,color="white") + + if x_pos == 0 and y_pos == len(y_dimension[0]) - 1: + axs[y_pos, x_pos].set_xlabel("X",fontsize=70,color="white") + axs[y_pos, x_pos].legend(rect, [to_label(n) for n in solver_names], + bbox_to_anchor=(0., -0.3, len(x_dimension[0]), 0.), loc=0, ncol=2, borderaxespad=0.) + + # set the title of the individual rows + for i in range(len(y_dimension[0])): + axs[i][-1].set_ylabel(y_dimension[1] + ' = ' + str(y_dimension[0][i]), rotation=90) + axs[i][-1].yaxis.set_label_coords(1.2, 0.5) + + # set the titles of the individual columns (and enlarge the canvas to make space for the title) + for i in range(len(x_dimension[0])): + axs[0][i].set_xlabel("\n\n\n\n" + x_dimension[1] + ' = ' + str(x_dimension[0][i]), va="center") + axs[0][i].xaxis.set_label_coords(0.5, 1.2) + + # set the background color to white (only required in pycharm) + fig.patch.set_facecolor('w') + + # label the common y axis + fig.text(0.06, 0.5, 'Runtime [ms]', ha='center', va='center', rotation='vertical') + + # set the figure title to the + fig.suptitle("%s = %d" % (fixed_dimension[1], fixed_pos), fontsize=14) + + plt.show() create_grid()