{ "cells": [ { "cell_type": "code", "execution_count": null, "source": [ "!pip install -q -U sagemaker ipywidgets" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "# ResNet-50 comparison: compiled vs uncompiled, featuring Inferentia\n", "\n", "In this notebook we will see how to deploy a pretrained model from the PyTorch Vision library, in particular a ResNet50, to Amazon SageMaker. We will also test how it performs on different hardware configurations, and the effects of model compilation with Amazon SageMaker Neo. In a nutshell, we will test:\n", "\n", "- ResNet50 on a ml.c5.xlarge, uncompiled\n", "- ResNet50 on a ml.g4dn.xlarge, uncompiled\n", "- ResNet50 on a ml.c5.xlarge, compiled\n", "- ResNet50 on a ml.g4dn.xlarge, compiled\n", "- ResNet50 on a ml.inf1.xlarge, compiled\n", "\n", "**NOTE**: this notebook has been tested with the PyTorch 1.8 CPU kernel. Please use that one if you're using SageMaker Studio." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Set-up model and SageMaker helper functions" ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "import sagemaker\n", "from sagemaker import Session, get_execution_role\n", "from sagemaker.pytorch.model import PyTorchModel\n", "from sagemaker.utils import name_from_base\n", "\n", "print(sagemaker.__version__)\n", "\n", "sess = Session()\n", "bucket = sess.default_bucket()\n", "role = get_execution_role()\n", "endpoints = {}" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's download the model for the PyTorch Hub, and create an archive that can be used by SageMaker to deploy this model. For using PyTorch in Script Mode, Amazon SageMaker expects a single archive file in `.tar.gz` format, containing a model file and the code for inference in a `code` folder. The structure of the archive will be as follows: \n", "\n", "```\n", "/model.tar.gz\n", "/--- model.pth\n", "/--- code/\n", "/--- /--- inference.py\n", "/--- /--- requirements.txt (optional)\n", "```\n", "\n", "By setting the variable `download_the_model=False`, you can skip the download phase and provide your own path to S3 in the `model_data` variable." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "download_the_model = True\n", "\n", "if download_the_model:\n", " import torch, tarfile\n", " # Load the model\n", " model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet50', pretrained=True)\n", " inp = torch.rand(1, 3, 224, 224)\n", " model_trace = torch.jit.trace(model, inp)\n", " # Save your model. The following code saves it with the .pth file extension\n", " model_trace.save('model.pth')\n", " with tarfile.open('model.tar.gz', 'w:gz') as f:\n", " f.add('model.pth')\n", " f.add('code/uncompiled-inference.py', 'code/inference.py')\n", " f.close()\n", " pytorch_resnet50_prefix = 'pytorch/resnet50'\n", " model_data = sess.upload_data('model.tar.gz', bucket, pytorch_resnet50_prefix)\n", "else:\n", " pytorch_resnet50_prefix = 'pytorch/resnet50'\n", " model_data = f's3://{bucket}/{pytorch_resnet50_prefix}/model.tar.gz'\n", " \n", "print(f'Model stored in {model_data}')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Deploy and test on CPU\n", "\n", "In our first test, we will deploy the model on a `ml.c5.xlarge` instance, without compiling the model. Although this is a CNN, it is still possible to run it on CPU, although the performances won't be that good. This can give us a nice baseline of the performances of our model." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "pth_model = PyTorchModel(model_data=model_data,\n", " entry_point='uncompiled-inference.py',\n", " source_dir='code',\n", " role=role,\n", " framework_version='1.7',\n", " py_version='py3'\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "predictor = pth_model.deploy(1, 'ml.c5.xlarge')" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "endpoints['cpu_uncompiled'] = predictor.endpoint_name\n", "predictor.endpoint_name" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Deploy and test on GPU\n", "\n", "The instance chosen this time is a `ml.g4dn.xlarge`. It has great throughput and the cheapest way of running GPU inferences on the AWS cloud." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "pth_model = PyTorchModel(model_data=model_data,\n", " entry_point='uncompiled-inference.py',\n", " source_dir='code',\n", " role=role,\n", " framework_version='1.6',\n", " py_version='py3'\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "predictor = pth_model.deploy(1, 'ml.g4dn.xlarge')" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "endpoints['gpu_uncompiled'] = predictor.endpoint_name\n", "predictor.endpoint_name" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "# Compiled Models\n", "\n", "A common tactic in more advanced use cases is to improve model performances, in terms of latency and throughput, by compiling the model. \n", "\n", "Amazon SageMaker features its own compiler, Amazon SageMaker Neo, that enables data scientists to optimize ML models for inference on SageMaker in the cloud and supported devices at the edge.\n", "\n", "You start with a machine learning model already built with DarkNet, Keras, MXNet, PyTorch, TensorFlow, TensorFlow-Lite, ONNX, or XGBoost and trained in Amazon SageMaker or anywhere else. Then you choose your target hardware platform, which can be a SageMaker hosting instance or an edge device based on processors from Ambarella, Apple, ARM, Intel, MediaTek, Nvidia, NXP, Qualcomm, RockChip, Texas Instruments, or Xilinx. With a single click, SageMaker Neo optimizes the trained model and compiles it into an executable. \n", "\n", "For inference in the cloud, SageMaker Neo speeds up inference and saves cost by creating an inference optimized container in SageMaker hosting. For inference at the edge, SageMaker Neo saves developers months of manual tuning by automatically tuning the model for the selected operating system and processor hardware." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Create the `model_data` for compilation\n", "\n", "To compile the model, we need to provide a `tar.gz` archive just like before, with very few changes. In particular, since SageMaker will use a different DL runtime for running compiled models, we will let it use the default function for serving the model, and only provide a script containing how to preprocess data. Let's create this archive and uplaod it to S3." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "import tarfile \n", "\n", "with tarfile.open('model-to-compile.tar.gz', 'w:gz') as f:\n", " f.add('model.pth')\n", " f.add('code/compiled-inference.py', 'code/inference.py')\n", "f.close()\n", "model_data = sess.upload_data('model-to-compile.tar.gz', bucket, pytorch_resnet50_prefix)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "output_path = f's3://{bucket}/{pytorch_resnet50_prefix}/compiled'" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Compile for CPU\n", "\n", "Let's run the same baseline test from before, and compile and deploy for CPU instances." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "pth_model = PyTorchModel(model_data=model_data,\n", " entry_point='compiled-inference.py',\n", " source_dir='code',\n", " role=role,\n", " framework_version='1.6',\n", " py_version='py3'\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "output_path = f's3://{bucket}/{pytorch_resnet50_prefix}/compiled'\n", "\n", "compiled_model = pth_model.compile(\n", " target_instance_family='ml_c5',\n", " input_shape={\"input0\": [1, 3, 224, 224]},\n", " output_path=output_path,\n", " role=role,\n", " job_name=name_from_base(f'pytorch-resnet50-c5')\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "predictor = compiled_model.deploy(1, 'ml.c5.xlarge')" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "endpoints['cpu_compiled'] = predictor.endpoint_name\n", "predictor.endpoint_name" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Compile for GPU" ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "pth_model = PyTorchModel(model_data=model_data,\n", " entry_point='compiled-inference.py',\n", " source_dir='code',\n", " role=role,\n", " framework_version='1.6',\n", " py_version='py3'\n", " )" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "output_path = f's3://{bucket}/{pytorch_resnet50_prefix}/compiled'\n", "\n", "compiled_model = pth_model.compile(\n", " target_instance_family='ml_g4dn',\n", " input_shape={\"input0\": [1, 3, 224, 224]},\n", " output_path=output_path,\n", " role=role,\n", " job_name=name_from_base(f'pytorch-resnet50-g4dn')\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "predictor = compiled_model.deploy(1, 'ml.g4dn.xlarge')" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "endpoints['gpu_compiled'] = predictor.endpoint_name\n", "predictor.endpoint_name" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "print(1)" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Compile for Inferentia instances\n", "\n", "There is one more thing we can try to improve our model performances: using Inferentia instances.\n", "\n", "Amazon EC2 Inf1 instances deliver high-performance ML inference at the lowest cost in the cloud. They deliver up to 2.3x higher throughput and up to 70% lower cost per inference than comparable current generation GPU-based Amazon EC2 instances. Inf1 instances are built from the ground up to support machine learning inference applications. They feature up to 16 AWS Inferentia chips, high-performance machine learning inference chips designed and built by AWS." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "pth_model = PyTorchModel(\n", " model_data=model_data,\n", " entry_point='compiled-inference.py',\n", " source_dir='code',\n", " role=role,\n", " framework_version='1.7',\n", " py_version='py3'\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "compiled_model = pth_model.compile(\n", " target_instance_family='ml_inf1',\n", " input_shape={\"input0\": [1, 3, 224, 224]},\n", " output_path=output_path,\n", " role=role,\n", " job_name=name_from_base(f'pytorch-resnet50-inf1'),\n", " compile_max_run=1000\n", ")" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "predictor = compiled_model.deploy(1, 'ml.inf1.xlarge')" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "endpoints['inferentia'] = predictor.endpoint_name\n", "predictor.endpoint_name" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "# Test" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "For testing our models and endpoints, we will use the following picture of a beagle pup, freely available on [Wikimedia](https://commons.wikimedia.org/wiki/File:Beagle_puppy_sitting_on_grass.jpg). We will pass it to our endpoints as `application/x-image`, and no particular pre-processing is needed on client-side. " ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "from IPython.display import Image\n", "\n", "Image('doggo.jpg')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Finally, we will use the following function to benchmark our SageMaker endpoints, measuring the latency of our predictions. This specific version uses both the `Predictor` from the SageMaker Python SDK and boto3's `invoke_endpoint()` function - just change the last parameter from `boto3` to `sm` if you want to use the Python SDK." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "from load_test import load_tester\n", "\n", "num_thread = 16\n", "\n", "from IPython.display import JSON\n", "JSON(endpoints)" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "# CPU - Uncompiled\n", "load_tester(num_thread, endpoints['cpu_uncompiled'], 'doggo.jpg', 'boto3')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's discuss the above results:\n", "\n", "as we can from the latency tests, the model way too long to generate an inference, averaging about 6 transactions per second (TPS). This of course may be sufficient for some low throughput use cases, rarely used instances, but it's very likely that it won't be sufficient. Let's see how those numbers change when using a GPU." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "# GPU - Uncompiled\n", "load_tester(num_thread, endpoints['gpu_uncompiled'], 'doggo.jpg', 'boto3')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Now we're talking! The GPU helps us achieve 77 TPS on average, with a much lower latency percentile over the board. Nice!" ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "# CPU - Compiled\n", "load_tester(num_thread, endpoints['cpu_compiled'], 'doggo.jpg', 'boto3')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "With a simple compilation job, we more than DOUBLED the performances of our model on our c5 instance, achieving 13 TPS and half the latency percentiles. Let's see if the same results can be seen on GPU." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "# GPU - Compiled\n", "load_tester(num_thread, endpoints['gpu_compiled'], 'doggo.jpg', 'boto3')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Results are also consistent in the compiled version of the model on GPU. Almost double the TPS, with 7 ms latency. Let's take it one step further and test Inferentia." ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "# Inferentia\n", "load_tester(num_thread, endpoints['inferentia'], 'doggo.jpg', 'boto3')" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "The best results so far! Up to 290 TPS at the same latency percentiles than GPU, or lower. All of this for a fraction of the cost." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "# Reviewing the results\n", "\n", "Let's plot the results obtained from the previous tests, by taking into account the last printed line of each load testing. We will ignore the error rate, and take into account the TPS obtained with our tests dividing it by the cost of the machine in the region of testing (DUB) - a metric we will call \"throughput per dollar\"." ], "metadata": {} }, { "cell_type": "code", "execution_count": 1, "source": [ "import matplotlib.pyplot as plt\n", "from io import StringIO\n", "import pandas as pd\n", "\n", "data = StringIO('''\n", "experiment|TPS|p50|cost/hour\n", "c5|5.900|215.23876|0.23\n", "c5 + Neo|12.900|121.60897|0.23\n", "g4dn|74.700|21.19393|0.821\n", "g4dn + Neo|140.400|11.28725|0.821\n", "inf1|304.300|4.90315|0.33\n", "''')\n", "\n", "df = pd.read_csv(data, sep='|')\n", "df['throughput per dollar (divided by 100, higher is better)'] = df['TPS']/df['cost/hour']/100 # Divide by 100 to normalize\n", "df['cost per 1M inferences in $ (lower is better)'] = (1000000/df['TPS'])/3600*df['cost/hour']\n", "df['number of inferences per dollar (higher is better)'] = df['TPS']*3600/df['cost/hour']\n", "df['transactions per hour'] = df['TPS']*3600\n", "\n", "df.head()" ], "outputs": [ { "output_type": "execute_result", "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", "
experimentTPSp50cost/hourthroughput per dollar (divided by 100, higher is better)cost per 1M inferences in $ (lower is better)number of inferences per dollar (higher is better)transactions per hour
0c55.9215.238760.2300.25652210.8286259.234783e+0421240.0
1c5 + Neo12.9121.608970.2300.5608704.9526272.019130e+0546440.0
2g4dn74.721.193930.8210.9098663.0529533.275518e+05268920.0
3g4dn + Neo140.411.287250.8211.7101101.6243276.156395e+05505440.0
4inf1304.34.903150.3309.2212120.3012383.319636e+061095480.0
\n", "
" ], "text/plain": [ " experiment TPS p50 cost/hour \\\n", "0 c5 5.9 215.23876 0.230 \n", "1 c5 + Neo 12.9 121.60897 0.230 \n", "2 g4dn 74.7 21.19393 0.821 \n", "3 g4dn + Neo 140.4 11.28725 0.821 \n", "4 inf1 304.3 4.90315 0.330 \n", "\n", " throughput per dollar (divided by 100, higher is better) \\\n", "0 0.256522 \n", "1 0.560870 \n", "2 0.909866 \n", "3 1.710110 \n", "4 9.221212 \n", "\n", " cost per 1M inferences in $ (lower is better) \\\n", "0 10.828625 \n", "1 4.952627 \n", "2 3.052953 \n", "3 1.624327 \n", "4 0.301238 \n", "\n", " number of inferences per dollar (higher is better) transactions per hour \n", "0 9.234783e+04 21240.0 \n", "1 2.019130e+05 46440.0 \n", "2 3.275518e+05 268920.0 \n", "3 6.156395e+05 505440.0 \n", "4 3.319636e+06 1095480.0 " ] }, "metadata": {}, "execution_count": 1 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 2, "source": [ "df.plot(x=\"experiment\", y=\"cost per 1M inferences in $ (lower is better)\", kind=\"bar\")" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 2 }, { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "code", "execution_count": 3, "source": [ "ax = df.plot(x=\"experiment\", y=\"cost per 1M inferences in $ (lower is better)\", legend=False, kind=\"bar\", color=\"red\", ylabel='cost in dollar ($)')\n", "ax.figure.legend()\n", "plt.rcParams[\"figure.figsize\"] = (8,5)\n", "plt.savefig('./images/cost-1M-inferences.png', dpi=300, format='png')\n", "plt.show()" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "code", "execution_count": 4, "source": [ "ax = df.plot(x=\"experiment\", y=\"number of inferences per dollar (higher is better)\", legend=False, kind=\"bar\", color=\"green\", ylabel=\"number of transactions\")\n", "ax.figure.legend()\n", "plt.yticks([0,500000,1000000,1500000,2000000,2500000, 3000000], [\"0\", \"500K\", \"1M\", \"1.5M\", \"2M\", \"2.5M\", \"3M\"])\n", "plt.rcParams[\"figure.figsize\"] = (8,5)\n", "plt.savefig('images/inferences-per dollar.png', dpi=300, format='png')\n", "plt.show()" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "code", "execution_count": 5, "source": [ "ax = df.plot(x=\"experiment\", y=\"transactions per hour\", legend=False, kind=\"bar\", color=\"blue\", ylabel=\"number of transactions\")\n", "ax.figure.legend()\n", "plt.rcParams[\"figure.figsize\"] = (8,5)\n", "plt.yticks([0,250000,500000,750000, 1000000], [\"0\", \"250K\", \"500K\", \"750K\", \"1M\"])\n", "plt.savefig('images/transactions-per-hour.png', dpi=300, format='png')\n", "plt.show()" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "code", "execution_count": 6, "source": [ "ax = df.plot(x=\"experiment\", y=\"cost/hour\", legend=False, kind=\"bar\", color=\"orange\", ylabel=\"number of transactions\")\n", "ax.figure.legend()\n", "plt.rcParams[\"figure.figsize\"] = (8,5)\n", "plt.savefig('images/cost-per-hour.png', dpi=300, format='png')\n", "plt.show()" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "The results speak for themselves. The `inf1` instance proves extremely competitive, thanks to its high TPS, incredibly low latency and undeniable value. Compiling the model for a GPU just like the `g4dn` is also a very interesting approach." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "# Clean-up" ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [ "for endpoint in endpoints:\n", " pred = sagemaker.predictor.Predictor(endpoint_name=endpoints[endpoint])\n", " pred.delete_endpoint()" ], "outputs": [], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [], "outputs": [], "metadata": {} } ], "metadata": { "instance_type": "ml.t3.medium", "interpreter": { "hash": "ac2eaa0ea0ebeafcc7822e65e46aa9d4f966f30b695406963e145ea4a91cd4fc" }, "kernelspec": { "display_name": "Python 3 (Data Science)", "language": "python", "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:eu-west-1:470317259841:image/datascience-1.0" }, "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.10" } }, "nbformat": 4, "nbformat_minor": 4 }