From 2a9aca0c1b13f030cce1671807217dbec269913c Mon Sep 17 00:00:00 2001 From: l-nmch Date: Sat, 9 May 2026 21:31:34 +0200 Subject: [PATCH] first commit --- .gitignore | 3 + LICENSE | 21 ++ README.md | 28 +++ app.py | 254 +++++++++++++++++++++++ notebook.ipynb | 540 ++++++++++++++++++++++++++++++++++++++++++++++++ requirement.txt | 42 ++++ 6 files changed, 888 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 app.py create mode 100644 notebook.ipynb create mode 100644 requirement.txt diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5805ae7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.venv/ +.csv +.png \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..4b0453f --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Eugene Rakhmatulin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..fba07a9 --- /dev/null +++ b/README.md @@ -0,0 +1,28 @@ +# Benchy-Graph + +Benchy-Graph is a tool that generates performance dashboards from llama-benchy CSV benchmark data. It visualizes key metrics like throughput, latency, and performance across different phases and concurrency levels for language model inference. + +## Generating the CSV File + +To generate the required CSV file, use [llama-benchy](https://github.com/eugr/llama-benchy), a benchmarking tool for llama.cpp servers. + +Example command to generate the CSV: + +```bash +uvx llama-benchy --base-url http://127.0.0.1:8000/v1 --model Qwen/Qwen3.6-27B --served-model-name unsloth/Qwen3.6-27B-GGUF --concurrency 1 2 4 8 16 32 --pp 128 --tg 128 --format csv +``` + +This will produce a CSV file with benchmark results that can be used as input for Benchy-Graph. + +## Running the App + +To generate a performance dashboard image from a CSV file: + +1. Ensure dependencies are installed: `pip install -r requirement.txt` +2. Run the script: `python app.py ` + +Replace `` with the path to your llama-benchy CSV file and `` with the desired output image path. + +## Running the Notebook + +For an interactive experience, open `notebook.ipynb` in Jupyter Notebook or JupyterLab and execute the cells. The notebook contains all the necessary code and explanations for generating visualizations. \ No newline at end of file diff --git a/app.py b/app.py new file mode 100644 index 0000000..5670874 --- /dev/null +++ b/app.py @@ -0,0 +1,254 @@ +""" +Benchy-Graph + +This script generates a performance dashboard from llama-benchy CSV benchmark data, +visualizing throughput, latency, and other metrics for different phases +and concurrency levels. + +Usage: + python test.py + +Dependencies: + - pandas + - matplotlib + - seaborn +""" + +import argparse +import re +import sys +from pathlib import Path + +import matplotlib.pyplot as plt +import pandas as pd +import seaborn as sns + +COLORS = { + 'pp': '#2E86AB', + 'tg': '#A23B72', + 'pp_tsr': '#7FB3D5', + 'tg_tsr': '#D98880', + 'pp_light': '#A7C7E7', + 'tg_light': '#E7B8D6' +} + +PLOT_STYLE = { + 'figure.figsize': [14, 10], + 'axes.linewidth': 1.2, + 'font_scale': 1.1 +} + +DASHBOARD_TITLE = ('Benchy-Graph | ') + + +def parse_arguments(): + """Parse command line arguments.""" + parser = argparse.ArgumentParser( + description='Generate Benchy-Graph from CSV data.' + ) + parser.add_argument('csv_path', help='Path to input CSV file') + parser.add_argument('image_path', help='Path to output image file') + return parser.parse_args() + + +def load_and_process_data(csv_path): + """ + Load CSV data and extract phase, param, and concurrency information. + + Args: + csv_path (str): Path to the CSV file + + Returns: + pd.DataFrame: Processed dataframe with extracted columns + + Raises: + FileNotFoundError: If CSV file doesn't exist + ValueError: If required columns are missing + """ + if not Path(csv_path).exists(): + raise FileNotFoundError(f"CSV file not found: {csv_path}") + + df = pd.read_csv(csv_path) + + model_name = None + if 'model' in df.columns and not df['model'].isna().all(): + model_name = str(df['model'].iloc[0]).strip() + + required_columns = ['test_name'] + missing_columns = [col for col in required_columns if col not in df.columns] + if missing_columns: + raise ValueError(f"Missing required columns: {missing_columns}") + + # Extract phase, param, concurrency from test_name + pattern = r'(pp|tg)\s*(\d+)\s*\(\s*c(\d+)\s*\)' + extracted = df['test_name'].str.extract(pattern) + df = df.assign( + phase=extracted[0], + param=pd.to_numeric(extracted[1], errors='coerce'), + concurrency=pd.to_numeric(extracted[2], errors='coerce') + ) + + # Drop rows with missing phase or concurrency + df = df.dropna(subset=['phase', 'concurrency']).copy() + return df, model_name + + +def setup_plot_style(): + """Configure matplotlib and seaborn plot styles.""" + sns.set_style("whitegrid") + sns.set_context("notebook", font_scale=PLOT_STYLE['font_scale']) + rcparams = {k: v for k, v in PLOT_STYLE.items() if k != 'font_scale'} + plt.rcParams.update(rcparams) + + +def plot_throughput_subplot(ax, df): + """Plot average throughput and request throughput on the given axis.""" + unique_concurrency = sorted(df['concurrency'].dropna().unique()) + phase_offsets = {'pp': -0.08, 'tg': 0.08} if len(unique_concurrency) <= 1 else {'pp': 0.0, 'tg': 0.0} + for phase, marker, color in [('pp', 'o', COLORS['pp']), ('tg', 's', COLORS['tg'])]: + # Average throughput + subset = df[(df['phase'] == phase) & (df['t_s_mean'].notna())] + if not subset.empty: + agg = subset.groupby('concurrency')['t_s_mean'].agg(['mean', 'std']).reset_index() + x = agg['concurrency'] + phase_offsets[phase] + ax.errorbar(x, agg['mean'], yerr=agg['std'], + marker=marker, label=f'{phase.upper()} avg speed', + color=color, capsize=4, linewidth=2, markersize=8) + + # Request throughput + subset_req = df[(df['phase'] == phase) & (df['t_s_req_mean'].notna())] + if not subset_req.empty: + agg_req = subset_req.groupby('concurrency')['t_s_req_mean'].agg(['mean', 'std']).reset_index() + x_req = agg_req['concurrency'] + phase_offsets[phase] + ax.errorbar(x_req, agg_req['mean'], yerr=agg_req['std'], + marker='^', label=f'{phase.upper()} t/s/r', + color=COLORS[f'{phase}_tsr'], linestyle='--', capsize=4, linewidth=2, markersize=8) + + ax.set_xlabel('Concurrency (number of requests)', fontsize=12) + ax.set_ylabel('Tokens/sec', fontsize=12) + ax.set_title('Avg throughput and request throughput', fontsize=13, fontweight='bold') + if unique_concurrency: + ax.set_xticks(unique_concurrency) + if len(unique_concurrency) == 1: + x = unique_concurrency[0] + ax.set_xlim(x - 0.5, x + 0.5) + else: + ax.set_xlim(min(unique_concurrency) - 0.5, max(unique_concurrency) + 0.5) + ax.legend(frameon=True, fancybox=True) + ax.grid(axis='y', alpha=0.4) + + +def plot_latency_subplot(ax, df): + """Plot start latency (TTFR) for prefill phase on the given axis.""" + df_pp = df[df['phase'] == 'pp'] + + if df_pp['ttfr_mean'].notna().any(): + agg_ttfr = df_pp.dropna(subset=['ttfr_mean']).groupby('concurrency')['ttfr_mean'].agg(['mean', 'std']).reset_index() + ax.errorbar(agg_ttfr['concurrency'], agg_ttfr['mean'], yerr=agg_ttfr['std'], + marker='o', label='TTFR (Time To First Response)', color=COLORS['pp'], capsize=4) + + ax.set_xlabel('Concurrency', fontsize=12) + ax.set_ylabel('Latency (ms)', fontsize=12) + ax.set_title('Start Latency (Prefill phase)', fontsize=13, fontweight='bold') + unique_concurrency = sorted(df_pp['concurrency'].dropna().unique()) + if unique_concurrency: + ax.set_xticks(unique_concurrency) + if len(unique_concurrency) == 1: + x = unique_concurrency[0] + ax.set_xlim(x - 0.5, x + 0.5) + else: + ax.set_xlim(min(unique_concurrency) - 0.5, max(unique_concurrency) + 0.5) + ax.legend(frameon=True, fancybox=True) + ax.grid(axis='y', alpha=0.4) + + +def plot_heatmap_subplot(ax, df): + """Plot throughput heatmap on the given axis.""" + pivot_throughput = df.dropna(subset=['t_s_mean']).pivot_table( + values='t_s_mean', index='phase', columns='concurrency', aggfunc='mean' + ) + if not pivot_throughput.empty: + sns.heatmap(pivot_throughput, annot=True, fmt='.1f', cmap='YlOrRd', ax=ax, + cbar_kws={'label': 'tokens/sec'}, linewidths=0.5) + ax.set_title('Avg Throughput (tokens/sec)', fontsize=13, fontweight='bold') + ax.set_xlabel('Concurrency') + ax.set_ylabel('Phase') + + +def create_summary_table(ax, df): + """Create summary table on the given axis.""" + ax.axis('off') + + summary_rows = [] + for phase in ['pp', 'tg']: + for conc in sorted(df['concurrency'].unique()): + subset = df[(df['phase'] == phase) & (df['concurrency'] == conc)] + if not subset.empty and subset['t_s_mean'].notna().any(): + row = { + 'Phase': phase.upper(), + 'Conc.': conc, + 'Avg Speed': (f"{subset['t_s_mean'].mean():.1f} ± {subset['t_s_mean'].std():.1f}" + if subset['t_s_mean'].notna().any() else 'N/A'), + 't/s/r': (f"{subset['t_s_req_mean'].mean():.1f} ± {subset['t_s_req_mean'].std():.1f}" + if subset['t_s_req_mean'].notna().any() else 'N/A'), + 'TTFR': (f"{subset['ttfr_mean'].mean():.1f}ms" + if subset['ttfr_mean'].notna().any() else "N/A"), + 'PPT': (f"{subset['est_ppt_mean'].mean():.2f}ms" + if subset['est_ppt_mean'].notna().any() else "N/A") + } + summary_rows.append(row) + + summary_df = pd.DataFrame(summary_rows) + if not summary_df.empty: + table = ax.table(cellText=summary_df.values, colLabels=summary_df.columns, + cellLoc='center', loc='center', colColours=[COLORS['pp']]*len(summary_df.columns)) + table.auto_set_font_size(False) + table.set_fontsize(9) + table.scale(1, 1.8) + for i in range(len(summary_df)): + color = COLORS['pp_light'] if i % 2 == 0 else COLORS['tg_light'] + for j in range(len(summary_df.columns)): + table[(i+1, j)].set_facecolor(color) + ax.set_title('Summary', fontsize=13, fontweight='bold', pad=20) + + +def generate_dashboard(df, image_path, model_name=None): + """ + Generate the complete dashboard plot and save to file. + + Args: + df (pd.DataFrame): Processed dataframe + image_path (str): Path to save the output image + """ + setup_plot_style() + + fig, axes = plt.subplots(2, 2, figsize=(16, 12)) + title = DASHBOARD_TITLE + if model_name: + title = f"{DASHBOARD_TITLE}{model_name}" + fig.suptitle(title, fontsize=18, fontweight='bold', y=1.02) + + plot_throughput_subplot(axes[0, 0], df) + plot_latency_subplot(axes[0, 1], df) + plot_heatmap_subplot(axes[1, 0], df) + create_summary_table(axes[1, 1], df) + + plt.tight_layout() + plt.savefig(image_path, dpi=300, bbox_inches='tight', facecolor='white') + if plt.get_backend().lower() != 'agg': + plt.show() + + +def main(): + """Main entry point.""" + try: + args = parse_arguments() + df, model_name = load_and_process_data(args.csv_path) + generate_dashboard(df, args.image_path, model_name=model_name) + except Exception as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/notebook.ipynb b/notebook.ipynb new file mode 100644 index 0000000..f81f213 --- /dev/null +++ b/notebook.ipynb @@ -0,0 +1,540 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c12e9580", + "metadata": {}, + "source": [ + "## 1. Import required libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "73263d6f", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from pathlib import Path" + ] + }, + { + "cell_type": "markdown", + "id": "b888cfc2", + "metadata": {}, + "source": [ + "## 2. Set the CSV filename\n", + "Set the path to your llama-benchy CSV file here." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2c452778", + "metadata": {}, + "outputs": [], + "source": [ + "csv_path = 'demo.csv' # Change this to your CSV file name" + ] + }, + { + "cell_type": "markdown", + "id": "44b960d6", + "metadata": {}, + "source": [ + "## 3. Load and process the data\n", + "This cell loads the CSV and extracts phase, parameter, and concurrency information from the `test_name` column." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ababc424", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
modeltest_namet_s_meant_s_stdt_s_req_meant_s_req_stdpeak_ts_meanpeak_ts_stdpeak_ts_req_meanpeak_ts_req_stdttfr_meanttfr_stdest_ppt_meanest_ppt_stde2e_ttft_meane2e_ttft_stdphaseparamconcurrency
0Qwen/Qwen3.6-27Bpp128 (c1)117.9967023.370324117.9967023.370324NaNNaNNaNNaN1093.82832534.4726421091.41059834.4726421093.82832534.472642pp1281
1Qwen/Qwen3.6-27Btg128 (c1)15.3452800.26520515.3452800.26520518.0000002.82842718.0000002.828427NaNNaNNaNNaNNaNNaNtg1281
2Qwen/Qwen3.6-27Bpp128 (c2)124.11143710.50319062.1591715.269383NaNNaNNaNNaN2089.281133168.5762452086.863406168.5762452089.281133168.576245pp1282
3Qwen/Qwen3.6-27Btg128 (c2)25.3587460.69918212.7195870.30238627.3333331.88561813.8333331.462494NaNNaNNaNNaNNaNNaNtg1282
4Qwen/Qwen3.6-27Bpp128 (c4)126.6534136.47682831.7007061.629999NaNNaNNaNNaN4084.579437198.9917234082.161710198.9917234084.579437198.991723pp1284
\n", + "
" + ], + "text/plain": [ + " model test_name t_s_mean t_s_std t_s_req_mean \\\n", + "0 Qwen/Qwen3.6-27B pp128 (c1) 117.996702 3.370324 117.996702 \n", + "1 Qwen/Qwen3.6-27B tg128 (c1) 15.345280 0.265205 15.345280 \n", + "2 Qwen/Qwen3.6-27B pp128 (c2) 124.111437 10.503190 62.159171 \n", + "3 Qwen/Qwen3.6-27B tg128 (c2) 25.358746 0.699182 12.719587 \n", + "4 Qwen/Qwen3.6-27B pp128 (c4) 126.653413 6.476828 31.700706 \n", + "\n", + " t_s_req_std peak_ts_mean peak_ts_std peak_ts_req_mean peak_ts_req_std \\\n", + "0 3.370324 NaN NaN NaN NaN \n", + "1 0.265205 18.000000 2.828427 18.000000 2.828427 \n", + "2 5.269383 NaN NaN NaN NaN \n", + "3 0.302386 27.333333 1.885618 13.833333 1.462494 \n", + "4 1.629999 NaN NaN NaN NaN \n", + "\n", + " ttfr_mean ttfr_std est_ppt_mean est_ppt_std e2e_ttft_mean \\\n", + "0 1093.828325 34.472642 1091.410598 34.472642 1093.828325 \n", + "1 NaN NaN NaN NaN NaN \n", + "2 2089.281133 168.576245 2086.863406 168.576245 2089.281133 \n", + "3 NaN NaN NaN NaN NaN \n", + "4 4084.579437 198.991723 4082.161710 198.991723 4084.579437 \n", + "\n", + " e2e_ttft_std phase param concurrency \n", + "0 34.472642 pp 128 1 \n", + "1 NaN tg 128 1 \n", + "2 168.576245 pp 128 2 \n", + "3 NaN tg 128 2 \n", + "4 198.991723 pp 128 4 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check file exists\n", + "if not Path(csv_path).exists():\n", + " raise FileNotFoundError(f'CSV file not found: {csv_path}')\n", + "\n", + "df = pd.read_csv(csv_path)\n", + "if 'test_name' not in df.columns:\n", + " raise ValueError('Missing required column: test_name')\n", + "\n", + "import re\n", + "pattern = r'(pp|tg)\\s*(\\d+)\\s*\\(\\s*c(\\d+)\\s*\\)'\n", + "extracted = df['test_name'].str.extract(pattern)\n", + "df['phase'] = extracted[0]\n", + "df['param'] = pd.to_numeric(extracted[1], errors='coerce')\n", + "df['concurrency'] = pd.to_numeric(extracted[2], errors='coerce')\n", + "df = df.dropna(subset=['phase', 'concurrency']).copy()\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "f7d117cc", + "metadata": {}, + "source": [ + "## 4. Set up plot style\n", + "This cell configures the appearance of the plots." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "90d42431", + "metadata": {}, + "outputs": [], + "source": [ + "COLORS = {\n", + " 'pp': '#2E86AB',\n", + " 'tg': '#A23B72',\n", + " 'pp_tsr': '#7FB3D5',\n", + " 'tg_tsr': '#D98880',\n", + " 'pp_light': '#A7C7E7',\n", + " 'tg_light': '#E7B8D6'\n", + "}\n", + "\n", + "PLOT_STYLE = {\n", + " 'figure.figsize': [14, 10],\n", + " 'axes.linewidth': 1.2,\n", + " 'font_scale': 1.1\n", + "}\n", + "\n", + "sns.set_style('whitegrid')\n", + "sns.set_context('notebook', font_scale=PLOT_STYLE['font_scale'])\n", + "rcparams = {k: v for k, v in PLOT_STYLE.items() if k != 'font_scale'}\n", + "plt.rcParams.update(rcparams)" + ] + }, + { + "cell_type": "markdown", + "id": "c9f4c0d5", + "metadata": {}, + "source": [ + "## 5. Plot average throughput and request throughput\n", + "This cell shows the average throughput and request throughput for each phase and concurrency." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "caf70db1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "unique_concurrency = sorted(df['concurrency'].dropna().unique())\n", + "phase_offsets = {'pp': -0.08, 'tg': 0.08} if len(unique_concurrency) <= 1 else {'pp': 0.0, 'tg': 0.0}\n", + "for phase, marker, color in [('pp', 'o', COLORS['pp']), ('tg', 's', COLORS['tg'])]:\n", + " subset = df[(df['phase'] == phase) & (df['t_s_mean'].notna())]\n", + " if not subset.empty:\n", + " agg = subset.groupby('concurrency')['t_s_mean'].agg(['mean', 'std']).reset_index()\n", + " x = agg['concurrency'] + phase_offsets[phase]\n", + " ax.errorbar(x, agg['mean'], yerr=agg['std'],\n", + " marker=marker, label=f'{phase.upper()} avg speed',\n", + " color=color, capsize=4, linewidth=2, markersize=8)\n", + " subset_req = df[(df['phase'] == phase) & (df['t_s_req_mean'].notna())]\n", + " if not subset_req.empty:\n", + " agg_req = subset_req.groupby('concurrency')['t_s_req_mean'].agg(['mean', 'std']).reset_index()\n", + " x_req = agg_req['concurrency'] + phase_offsets[phase]\n", + " ax.errorbar(x_req, agg_req['mean'], yerr=agg_req['std'],\n", + " marker='^', label=f'{phase.upper()} t/s/r',\n", + " color=COLORS[f'{phase}_tsr'], linestyle='--', capsize=4, linewidth=2, markersize=8)\n", + "ax.set_xlabel('Concurrency (number of requests)', fontsize=12)\n", + "ax.set_ylabel('Tokens/sec', fontsize=12)\n", + "ax.set_title('Avg throughput and request throughput', fontsize=13, fontweight='bold')\n", + "if unique_concurrency:\n", + " ax.set_xticks(unique_concurrency)\n", + " if len(unique_concurrency) == 1:\n", + " x = unique_concurrency[0]\n", + " ax.set_xlim(x - 0.5, x + 0.5)\n", + " else:\n", + " ax.set_xlim(min(unique_concurrency) - 0.5, max(unique_concurrency) + 0.5)\n", + "ax.legend(frameon=True, fancybox=True)\n", + "ax.grid(axis='y', alpha=0.4)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cbfbcc9a", + "metadata": {}, + "source": [ + "## 6. Plot start latency (TTFR) for prefill phase\n", + "This cell shows the start latency (Time To First Response) for the prefill phase." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d13796d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "df_pp = df[df['phase'] == 'pp']\n", + "if df_pp['ttfr_mean'].notna().any():\n", + " agg_ttfr = df_pp.dropna(subset=['ttfr_mean']).groupby('concurrency')['ttfr_mean'].agg(['mean', 'std']).reset_index()\n", + " ax.errorbar(agg_ttfr['concurrency'], agg_ttfr['mean'], yerr=agg_ttfr['std'],\n", + " marker='o', label='TTFR (Time To First Response)', color=COLORS['pp'], capsize=4)\n", + "ax.set_xlabel('Concurrency', fontsize=12)\n", + "ax.set_ylabel('Latency (ms)', fontsize=12)\n", + "ax.set_title('Start Latency (Prefill phase)', fontsize=13, fontweight='bold')\n", + "unique_concurrency = sorted(df_pp['concurrency'].dropna().unique())\n", + "if unique_concurrency:\n", + " ax.set_xticks(unique_concurrency)\n", + " if len(unique_concurrency) == 1:\n", + " x = unique_concurrency[0]\n", + " ax.set_xlim(x - 0.5, x + 0.5)\n", + " else:\n", + " ax.set_xlim(min(unique_concurrency) - 0.5, max(unique_concurrency) + 0.5)\n", + "ax.legend(frameon=True, fancybox=True)\n", + "ax.grid(axis='y', alpha=0.4)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "87f305ad", + "metadata": {}, + "source": [ + "## 7. Plot throughput heatmap\n", + "This cell shows a heatmap of average throughput (tokens/sec) for each phase and concurrency." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "19651dd0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "pivot_throughput = df.dropna(subset=['t_s_mean']).pivot_table(\n", + " values='t_s_mean', index='phase', columns='concurrency', aggfunc='mean'\n", + ")\n", + "if not pivot_throughput.empty:\n", + " sns.heatmap(pivot_throughput, annot=True, fmt='.1f', cmap='YlOrRd', ax=ax,\n", + " cbar_kws={'label': 'tokens/sec'}, linewidths=0.5)\n", + " ax.set_title('Avg Throughput (tokens/sec)', fontsize=13, fontweight='bold')\n", + " ax.set_xlabel('Concurrency')\n", + " ax.set_ylabel('Phase')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b0f87123", + "metadata": {}, + "source": [ + "## 8. Show summary table\n", + "This cell displays a summary table of the main metrics for each phase and concurrency." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6b8e8537", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "fig, ax = plt.subplots(figsize=(8, 3))\n", + "ax.axis('off')\n", + "summary_rows = []\n", + "for phase in ['pp', 'tg']:\n", + " for conc in sorted(df['concurrency'].unique()):\n", + " subset = df[(df['phase'] == phase) & (df['concurrency'] == conc)]\n", + " if not subset.empty and subset['t_s_mean'].notna().any():\n", + " row = {\n", + " 'Phase': phase.upper(),\n", + " 'Conc.': conc,\n", + " 'Avg Speed': (f\"{subset['t_s_mean'].mean():.1f} ± {subset['t_s_mean'].std():.1f}\"\n", + " if subset['t_s_mean'].notna().any() else 'N/A'),\n", + " 't/s/r': (f\"{subset['t_s_req_mean'].mean():.1f} ± {subset['t_s_req_mean'].std():.1f}\"\n", + " if subset['t_s_req_mean'].notna().any() else 'N/A'),\n", + " 'TTFR': (f\"{subset['ttfr_mean'].mean():.1f}ms\"\n", + " if subset['ttfr_mean'].notna().any() else \"N/A\"),\n", + " 'PPT': (f\"{subset['est_ppt_mean'].mean():.2f}ms\"\n", + " if subset['est_ppt_mean'].notna().any() else \"N/A\")\n", + " }\n", + " summary_rows.append(row)\n", + "summary_df = pd.DataFrame(summary_rows)\n", + "if not summary_df.empty:\n", + " table = ax.table(cellText=summary_df.values, colLabels=summary_df.columns,\n", + " cellLoc='center', loc='center', colColours=[COLORS['pp']]*len(summary_df.columns))\n", + " table.auto_set_font_size(False)\n", + " table.set_fontsize(9)\n", + " table.scale(1, 1.8)\n", + " for i in range(len(summary_df)):\n", + " color = COLORS['pp_light'] if i % 2 == 0 else COLORS['tg_light']\n", + " for j in range(len(summary_df.columns)):\n", + " table[(i+1, j)].set_facecolor(color)\n", + " ax.set_title('Summary', fontsize=13, fontweight='bold', pad=70)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.10.12)", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirement.txt b/requirement.txt new file mode 100644 index 0000000..f91ea37 --- /dev/null +++ b/requirement.txt @@ -0,0 +1,42 @@ +asttokens==3.0.1 +comm==0.2.3 +contourpy==1.3.2 +cycler==0.12.1 +debugpy==1.8.20 +decorator==5.2.1 +exceptiongroup==1.3.1 +executing==2.2.1 +fonttools==4.62.1 +ipykernel==7.2.0 +ipython==8.39.0 +jedi==0.19.2 +jupyter_client==8.8.0 +jupyter_core==5.9.1 +kiwisolver==1.5.0 +matplotlib==3.10.9 +matplotlib-inline==0.2.1 +nest-asyncio==1.6.0 +numpy==2.2.6 +packaging==26.2 +pandas==2.3.3 +parso==0.8.6 +pexpect==4.9.0 +pillow==12.2.0 +platformdirs==4.9.6 +prompt_toolkit==3.0.52 +psutil==7.2.2 +ptyprocess==0.7.0 +pure_eval==0.2.3 +Pygments==2.20.0 +pyparsing==3.3.2 +python-dateutil==2.9.0.post0 +pytz==2026.1.post1 +pyzmq==27.1.0 +seaborn==0.13.2 +six==1.17.0 +stack-data==0.6.3 +tornado==6.5.5 +traitlets==5.14.3 +typing_extensions==4.15.0 +tzdata==2026.2 +wcwidth==0.6.0