From c28a17f50c0ed68f3d973398a0e1969b6a148797 Mon Sep 17 00:00:00 2001 From: Egor Klevak Date: Tue, 9 May 2023 13:09:13 -0700 Subject: [PATCH] Adding notebook with concurrent profiling calls to the service (#241) * Added screenshot of the metrics table and links to the design and evaluations. * Added screenshot of the metrics table and links to the design and evaluations. * Updated function for the service invocation * Removing unintended file * Added links to the annotation guidelines * Removing unused import of base64 * Adding notebook with concurrent profiling calls * Removing empty cells * Fixing typos --- ...le_timo_service_invocation_profiling.ipynb | 298 ++++++++++++++++++ .../integration_test.py | 1 - 2 files changed, 298 insertions(+), 1 deletion(-) create mode 100644 src/ai2_internal/figure_table_predictors/figure_table_timo_service_invocation_profiling.ipynb diff --git a/src/ai2_internal/figure_table_predictors/figure_table_timo_service_invocation_profiling.ipynb b/src/ai2_internal/figure_table_predictors/figure_table_timo_service_invocation_profiling.ipynb new file mode 100644 index 00000000..370f86ec --- /dev/null +++ b/src/ai2_internal/figure_table_predictors/figure_table_timo_service_invocation_profiling.ipynb @@ -0,0 +1,298 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 14, + "id": "48c1ef46-ef7a-4849-b832-e1e39f9bd0e5", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T11:59:41.447228Z", + "end_time": "2023-05-02T11:59:41.570896Z" + } + }, + "outputs": [], + "source": [ + "from mmda.types import *" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e43e9a67-6431-4002-9579-39a724afff88", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T11:59:42.029914Z", + "end_time": "2023-05-02T11:59:42.032573Z" + } + }, + "outputs": [], + "source": [ + "import logging\n", + "logger = logging.getLogger(__name__)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "outputs": [], + "source": [ + "from ai2_internal.figure_table_predictors.interface import Instance\n", + "import os\n", + "from ai2_internal import api\n", + "import mmda.types as mmda_types\n", + "import json\n", + "\n", + "def resolve(file: str) -> str:\n", + " return os.path.join('./test_fixtures', file)\n", + "\n", + "def get_test_instance(sha) -> Instance:\n", + " doc_file = resolve(f'test_doc_sha_{sha}.json')\n", + " with open(doc_file) as f:\n", + " dic_json = json.load(f)\n", + " return dic_json" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2023-05-02T12:11:21.591926Z", + "end_time": "2023-05-02T12:11:21.593500Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "872c7b95-6266-4ba5-867d-82e3fb6c7108", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T12:13:25.465458Z", + "end_time": "2023-05-02T12:13:25.610475Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "def generate_content(sha):\n", + " doc_json = get_test_instance(sha)\n", + " doc = doc_json['doc']\n", + " return {\n", + " \"symbols\": doc['symbols'],\n", + " \"tokens\": doc['tokens'],\n", + " \"pages\": doc['pages'],\n", + " \"vila_span_groups\": doc['vila_span_groups'],\n", + " \"blocks\": doc_json['layout_equations'],\n", + " }\n", + "\n", + "def process_table_figure(content, local=True, multiple=1):\n", + " if local:\n", + " url='http://localhost:8080/invocations'\n", + " else:\n", + " url = 'http://mmda-figure-cap-pred.v2.prod.models.s2.allenai.org/invocations'\n", + "\n", + " start = time.time()\n", + " try:\n", + " result = requests.post(url, json={\n", + " \"instances\": [content]*multiple})\n", + " except requests.exceptions.ReadTimeout: \n", + " pass\n", + "\n", + " print(f'Call time: {time.time() - start} seconds')\n", + "\n", + " return (result, time.time() - start)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "30e48266-78cc-470e-80ed-a514151029ea", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T12:06:49.261946Z", + "end_time": "2023-05-02T12:06:49.267985Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "9e438dc4-b712-40dd-aeb8-0cdb9f8bb02f", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T12:06:50.049561Z", + "end_time": "2023-05-02T12:06:50.054817Z" + } + }, + "outputs": [], + "source": [ + "import requests\n", + "from concurrent.futures import ThreadPoolExecutor, as_completed\n", + "\n", + "def process_table_figure_concurent(content, local=True, multiple=1, concurrent_requests=10):\n", + " if local:\n", + " url = 'http://localhost:8080/invocations'\n", + " else:\n", + " url = 'http://mmda-figure-cap-pred.v2.prod.models.s2.allenai.org/invocations'\n", + "\n", + " def send_request():\n", + " start = time.time()\n", + " try:\n", + " result = requests.post(url, json={\"instances\": [content] * multiple}, timeout=120)\n", + " except requests.exceptions.ReadTimeout:\n", + " pass\n", + " return time.time() - start\n", + "\n", + " with ThreadPoolExecutor(max_workers=concurrent_requests) as executor:\n", + " futures = [executor.submit(send_request) for _ in range(concurrent_requests)]\n", + "\n", + " response_times = [future.result() for future in as_completed(futures)]\n", + "\n", + " print(f'Call times: {response_times} seconds')\n", + " print(f'Average call time: {np.average(response_times):.2f} seconds std: {np.std(response_times):.2f}, concurent requests {concurrent_requests}')\n", + " return response_times" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "outputs": [], + "source": [ + "content = generate_content('d0450478c38dda61f9943f417ab9fcdb2ebeae0a')" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2023-05-02T12:13:28.547210Z", + "end_time": "2023-05-02T12:13:28.843678Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "5feb5329-8f0a-4877-8018-662dbafe8fba", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T12:13:38.128898Z", + "end_time": "2023-05-02T12:14:12.965511Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Call times: [1.400001049041748] seconds\n", + "Average call time: 1.40 seconds std: 0.00, concurent requests 1\n", + "Call times: [1.4494168758392334, 1.9214510917663574] seconds\n", + "Average call time: 1.69 seconds std: 0.24, concurent requests 2\n", + "Call times: [1.4738659858703613, 1.659148931503296, 1.9143550395965576] seconds\n", + "Average call time: 1.68 seconds std: 0.18, concurent requests 3\n", + "Call times: [1.6855049133300781, 1.7503199577331543, 2.171604871749878, 2.8290040493011475] seconds\n", + "Average call time: 2.11 seconds std: 0.46, concurent requests 4\n", + "Call times: [3.0311622619628906, 5.55782675743103, 5.702712059020996, 2.9607818126678467, 4.632144927978516] seconds\n", + "Average call time: 4.38 seconds std: 1.19, concurent requests 5\n", + "Call times: [4.024920225143433, 3.444732904434204, 2.084078073501587, 3.9703519344329834, 1.8279399871826172, 4.025630950927734] seconds\n", + "Average call time: 3.23 seconds std: 0.93, concurent requests 6\n", + "Call times: [2.4059410095214844, 3.4998137950897217, 2.4905200004577637, 3.4603328704833984, 5.1612138748168945, 5.26596212387085, 3.494436264038086] seconds\n", + "Average call time: 3.68 seconds std: 1.06, concurent requests 7\n", + "Call times: [2.842933177947998, 4.663649082183838, 3.921501874923706, 3.4676191806793213, 4.249823808670044, 3.160644769668579, 3.0885989665985107, 5.589174032211304] seconds\n", + "Average call time: 3.87 seconds std: 0.87, concurent requests 8\n", + "Call times: [3.414668083190918, 5.664439916610718, 3.953460931777954, 2.412278175354004, 3.599186897277832, 3.316335916519165, 4.343087911605835, 3.7883291244506836, 5.769091844558716] seconds\n", + "Average call time: 4.03 seconds std: 1.03, concurent requests 9\n" + ] + } + ], + "source": [ + "call_times = {}\n", + "for concurent_req in range(1, 10):\n", + " call_times[concurent_req] = process_table_figure_concurent(content, local=False, multiple=1, concurrent_requests=concurent_req)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "f1ed418f-b6e5-41e8-942c-8a4dd94b36bc", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T12:14:12.968163Z", + "end_time": "2023-05-02T12:14:13.214839Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "b5369922-e7a4-4b6f-a07e-d7ac597fc6b3", + "metadata": { + "tags": [], + "ExecuteTime": { + "start_time": "2023-05-02T12:36:50.438266Z", + "end_time": "2023-05-02T12:36:50.548366Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": "Text(0, 0.5, 'Average response times (sec)')" + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(list(call_times.keys()), [np.average(response_times) for response_times in call_times.values()], \n", + " [np.std(response_times) for response_times in call_times.values()])\n", + "plt.xlabel('Concurrence')\n", + "plt.ylabel('Average response times (sec)')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mmda", + "language": "python", + "name": "mmda" + }, + "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.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/ai2_internal/figure_table_predictors/integration_test.py b/src/ai2_internal/figure_table_predictors/integration_test.py index 1ec33be6..74f1f1eb 100644 --- a/src/ai2_internal/figure_table_predictors/integration_test.py +++ b/src/ai2_internal/figure_table_predictors/integration_test.py @@ -34,7 +34,6 @@ def test_prediction(self, container): from .. import api from mmda.types.document import Document -from mmda.types.image import tobase64 from .interface import Instance import mmda.types as mmda_types