diff --git a/.github/workflows/test_openvino_notebooks.yml b/.github/workflows/test_openvino_notebooks.yml index abc2a65440..7b037d0565 100644 --- a/.github/workflows/test_openvino_notebooks.yml +++ b/.github/workflows/test_openvino_notebooks.yml @@ -49,5 +49,7 @@ jobs: - name: Test with Pytest run: | + sed -i 's/NUM_TRAIN_ITEMS = 600/NUM_TRAIN_ITEMS = 10/' notebooks/openvino/question_answering_quantization.ipynb + sed -i 's/# %pip install/%pip install/' notebooks/openvino/optimum_openvino_inference.ipynb python -m pytest --nbval-lax notebooks/openvino/optimum_openvino_inference.ipynb notebooks/openvino/question_answering_quantization.ipynb diff --git a/notebooks/openvino/optimum_openvino_inference.ipynb b/notebooks/openvino/optimum_openvino_inference.ipynb index 446e668911..b94238d358 100644 --- a/notebooks/openvino/optimum_openvino_inference.ipynb +++ b/notebooks/openvino/optimum_openvino_inference.ipynb @@ -9,7 +9,7 @@ "\n", "This notebook is a playground for running inference with OpenVINO on Transformers models with Optimum. The first part of this notebook explains the different ways to load a model, and some options specific to OpenVINO, like doing inference on an Intel GPU. The second part of this notebook consists of small examples for different supported tasks. \n", "\n", - "Do not forget to install the required dependencies before running this notebook with `pip install optimum[openvino] ipywidgets pillow torchaudio` or uncomment the cell below to install these requirements in your current Python environment. The audio classification example requires [ffmpeg](https://ffmpeg.org/download.html)." + "Do not forget to install the required dependencies before running this notebook by uncommenting the cell below to install these requirements in your current Python environment. The audio classification example requires [ffmpeg](https://ffmpeg.org/download.html)." ] }, { @@ -17,18 +17,11 @@ "execution_count": 1, "id": "6a6774ad-912b-4053-b7f6-14dc020807ef", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:17.121564Z", - "iopub.status.busy": "2023-03-12T19:47:17.121264Z", - "iopub.status.idle": "2023-03-12T19:47:17.125098Z", - "shell.execute_reply": "2023-03-12T19:47:17.124669Z", - "shell.execute_reply.started": "2023-03-12T19:47:17.121531Z" - }, "tags": [] }, "outputs": [], "source": [ - "# %pip install optimum[openvino] ipywidgets pillow torchaudio" + "# %pip install optimum[openvino] ipywidgets pillow torchaudio soundfile librosa" ] }, { @@ -52,13 +45,6 @@ "execution_count": 2, "id": "0c89b2a2-ce31-4773-9454-3e0e57d1a231", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:17.127386Z", - "iopub.status.busy": "2023-03-12T19:47:17.127169Z", - "iopub.status.idle": "2023-03-12T19:47:24.576408Z", - "shell.execute_reply": "2023-03-12T19:47:24.575840Z", - "shell.execute_reply.started": "2023-03-12T19:47:17.127372Z" - }, "tags": [] }, "outputs": [ @@ -66,15 +52,26 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/openvino/offline_transformations/__init__.py:10: FutureWarning: The module is private and following namespace `offline_transformations` will be removed in the future.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, onnx, openvino\n" + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/diffusers/utils/outputs.py:63: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " torch.utils._pytree._register_pytree_node(\n", + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/diffusers/utils/outputs.py:63: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " torch.utils._pytree._register_pytree_node(\n", + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", + " _torch_pytree._register_pytree_node(\n", + "Framework not specified. Using pt to export the model.\n", + "Using the export variant default. Available variants are:\n", + " - default: The default ONNX variant.\n", + "Using framework PyTorch: 2.2.0+cpu\n", + "/home/helena/venvs/openvino_env/lib/python3.10/site-packages/transformers/models/distilbert/modeling_distilbert.py:246: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n", + " mask, torch.tensor(torch.finfo(scores.dtype).min)\n", + "Compiling the model to CPU ...\n", + "Compiling the model to CPU ...\n" ] } ], @@ -104,13 +101,6 @@ "execution_count": 3, "id": "8053abe3-0e1f-445d-8397-630efac28269", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:24.577918Z", - "iopub.status.busy": "2023-03-12T19:47:24.577422Z", - "iopub.status.idle": "2023-03-12T19:47:25.276093Z", - "shell.execute_reply": "2023-03-12T19:47:25.275685Z", - "shell.execute_reply.started": "2023-03-12T19:47:24.577895Z" - }, "tags": [] }, "outputs": [ @@ -154,13 +144,6 @@ "execution_count": 4, "id": "dcf7a5c3-81ba-42cb-a7d9-d22c5bb00325", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:25.276779Z", - "iopub.status.busy": "2023-03-12T19:47:25.276603Z", - "iopub.status.idle": "2023-03-12T19:47:25.278703Z", - "shell.execute_reply": "2023-03-12T19:47:25.278355Z", - "shell.execute_reply.started": "2023-03-12T19:47:25.276764Z" - }, "tags": [] }, "outputs": [], @@ -174,20 +157,20 @@ "execution_count": 5, "id": "648a8eb1-1d50-4503-8094-c9a88098bee9", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:25.279302Z", - "iopub.status.busy": "2023-03-12T19:47:25.279139Z", - "iopub.status.idle": "2023-03-12T19:47:26.802333Z", - "shell.execute_reply": "2023-03-12T19:47:26.801969Z", - "shell.execute_reply.started": "2023-03-12T19:47:25.279288Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "text/plain": [ - "{'score': 0.8515876531600952,\n", + "{'score': 0.8515874147415161,\n", " 'start': 12,\n", " 'end': 64,\n", " 'answer': 'a framework for deep learning inference optimization'}" @@ -234,16 +217,16 @@ "execution_count": 6, "id": "c5d8d4be-3449-4a78-aa92-56ef2b355572", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:26.802936Z", - "iopub.status.busy": "2023-03-12T19:47:26.802808Z", - "iopub.status.idle": "2023-03-12T19:47:27.259642Z", - "shell.execute_reply": "2023-03-12T19:47:27.259125Z", - "shell.execute_reply.started": "2023-03-12T19:47:26.802923Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "text/plain": [ @@ -285,10 +268,10 @@ "### OpenVINO features\n", "\n", "- For improved performance, it is sometimes useful to reshape the model to use static input shapes\n", - "- Models can be compressed to FP16, which reduces model size by half, and improves performance on GPU (because GPUs contain optimizations for computations with FP16 data).\n", + "- On GPU, inference uses FP16 by default (GPUs contain optimizations for computations with FP16 data). On 4th generation and later Intel® Xeon® Scalable Processors, inference uses BF16 by default. \n", "- OpenVINO supports inference on Intel GPU, either an integrated GPU in your laptop or desktop, or an Intel discrete GPU, for example Intel Arc. \n", "\n", - "By default, when loading a model with `model = OVModelForXxx.from_pretrained(model_id)`, it is compiled on CPU. If you know you want to use GPU inference, static shapes, or FP16, you can set `compile=False` to the `.from_pretrained()` method, to skip the compilation step, as the model will have to be compiled again after steps such as reshaping, fp16 conversion or changing device. The model can then be compile with `model.compile()`. In the case the model was not compiled, it will be automatically done before the first inference, resulting in an increase of the first inference latency, since it will include the model compilation time." + "By default, when loading a model with `model = OVModelForXxx.from_pretrained(model_id)`, it is compiled on CPU. If you need to modify the model, for example to use static shapes, you can set `compile=False` to the `.from_pretrained()` method, to skip the compilation step, as the model will have to be compiled again after steps such as reshaping or changing device. The model can then be compile with `model.compile()`. In the case the model was not compiled, it will be automatically done before the first inference, resulting in an increase of the first inference latency, since it will include the model compilation time." ] }, { @@ -316,20 +299,20 @@ "execution_count": 7, "id": "e0754efa-0beb-4060-8633-daecc5ebca31", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:27.261759Z", - "iopub.status.busy": "2023-03-12T19:47:27.261529Z", - "iopub.status.idle": "2023-03-12T19:47:31.027499Z", - "shell.execute_reply": "2023-03-12T19:47:31.027078Z", - "shell.execute_reply.started": "2023-03-12T19:47:27.261738Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "text/plain": [ - "{'score': 0.7991431951522827,\n", + "{'score': 0.7991424798965454,\n", " 'start': 12,\n", " 'end': 62,\n", " 'answer': 'a toolkit for deep learning inference optimization'}" @@ -366,12 +349,12 @@ }, { "cell_type": "markdown", - "id": "3a564882-dfd2-4f62-803b-f1e3485736c3", + "id": "8798b8d5-50ad-439f-a1d8-886d579a91fe", "metadata": {}, "source": [ - "#### Compressing model weights to FP16\n", + "#### Saving Model in FP16 format\n", "\n", - "Compressing model weights saves disk space, and speeds up inference on Intel GPU." + "`model.half()` converts the model weights to FP16 precision. This reduces the size of the model by half, with usually a negligible impact on accuracy." ] }, { @@ -379,13 +362,6 @@ "execution_count": 8, "id": "09f443d5-ff58-416c-ab70-bee16e9f8235", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:31.028314Z", - "iopub.status.busy": "2023-03-12T19:47:31.028164Z", - "iopub.status.idle": "2023-03-12T19:47:32.026899Z", - "shell.execute_reply": "2023-03-12T19:47:32.026017Z", - "shell.execute_reply.started": "2023-03-12T19:47:31.028301Z" - }, "tags": [] }, "outputs": [], @@ -401,7 +377,16 @@ "source": [ "#### Loading Model on GPU\n", "\n", - "For GPU inference, we recommend using FP16. OpenVINO support for dynamic shapes on GPU is in preview mode, so for now we recommend using static shapes.\n", + "A model can be loaded to GPU by using `model.to(\"GPU\")` or by passing `device` to `from_pretrained()`.\n", + "\n", + "GPU inference will automatically run with FP16 precision, regardless of the precision of the weights of the model. To override this, and force FP32 precision you can pass an `ov_config` argument to `.from_pretrained()`: \n", + "\n", + "```\n", + "model = OVModelForQuestionAnswering.from_pretrained(model_id,\n", + " device_name=\"GPU\",\n", + " ov_config={\"INFERENCE_PRECISION_HINT\": \"f32\"}\n", + ")\n", + "```\n", "\n", "OpenVINO's `Core().available_devices` property shows the supported devices on the system. " ] @@ -411,13 +396,6 @@ "execution_count": 9, "id": "09f13ef7-2321-47c6-a08f-5fbe61b32b43", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:32.029229Z", - "iopub.status.busy": "2023-03-12T19:47:32.028882Z", - "iopub.status.idle": "2023-03-12T19:47:32.061033Z", - "shell.execute_reply": "2023-03-12T19:47:32.060524Z", - "shell.execute_reply.started": "2023-03-12T19:47:32.029205Z" - }, "tags": [] }, "outputs": [ @@ -426,7 +404,7 @@ "output_type": "stream", "text": [ "CPU 11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz\n", - "GPU Intel(R) Iris(R) Xe Graphics [0x9a49] (iGPU)\n" + "GPU Intel(R) Iris(R) Xe Graphics (iGPU)\n" ] } ], @@ -442,16 +420,17 @@ "execution_count": 10, "id": "bf5194b5-5e80-4597-85d4-fab72fbed2fa", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:32.061881Z", - "iopub.status.busy": "2023-03-12T19:47:32.061689Z", - "iopub.status.idle": "2023-03-12T19:47:33.067283Z", - "shell.execute_reply": "2023-03-12T19:47:33.066928Z", - "shell.execute_reply.started": "2023-03-12T19:47:32.061868Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to GPU ...\n", + "Setting OpenVINO CACHE_DIR to /home/helena/.cache/huggingface/hub/models--helenai--distilbert-base-uncased-distilled-squad-ov-fp32/snapshots/a9da64102a84c4b3f110c4d627937a110e56257f/model_cache\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -461,15 +440,35 @@ } ], "source": [ - "# Compile the model on GPU if a GPU is found\n", + "# Use `model.to()` to compile the model on GPU if a GPU is found\n", "if \"GPU\" in Core().available_devices:\n", - " model.half()\n", " model.reshape(1, 28)\n", " model.to(\"gpu\")\n", " model.compile()\n", " print(ov_pipe.model._device)" ] }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2538c02e-fa35-459f-90fb-e6667ef8747b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to GPU ...\n", + "Setting OpenVINO CACHE_DIR to distilbert-base-uncased-distilled-squad-ov-fp16/model_cache\n" + ] + } + ], + "source": [ + "# Set the device directly with `.from_pretrained()`\n", + "if \"GPU\" in Core().available_devices:\n", + " model = OVModelForQuestionAnswering.from_pretrained(\"distilbert-base-uncased-distilled-squad-ov-fp16\", device=\"GPU\")" + ] + }, { "cell_type": "markdown", "id": "8e3a06fd-e51b-404e-b82a-2557e3db1375", @@ -507,23 +506,48 @@ "source": [ "Audio classification is the task of automatically categorizing audio data into classes or categories. See Hugging Face's [audio-classification](https://huggingface.co/tasks/audio-classificationhttps://huggingface.co/tasks/audio-classification) documentation for more information.\n", "\n", - "In this example, we use the [MIT/ast-finetuned-speech-commands-v2](https://huggingface.co/MIT/ast-finetuned-speech-commands-v2) model to do inference on an audio file from the [speech commands](https://huggingface.co/datasets/speech_commands/viewer/v0.01/test) dataset. You can try your own audio file too. To see the classes that this model was trained on, run `model.config.id2label`\n", + "In this example, we use the [MIT/ast-finetuned-speech-commands-v2](https://huggingface.co/MIT/ast-finetuned-speech-commands-v2) model to do inference on an audio file from the [speech commands](https://huggingface.co/datasets/speech_commands/viewer/v0.01/test) dataset. You can try your own audio file too. To do that, set `audio_sample = /path/to/audio_file`. To see the classes that this model was trained on, run `model.config.id2label`\n", "\n", "The model pipeline needs ffmpeg. On Ubuntu Linux: `sudo apt install ffmpeg`; see https://ffmpeg.org/download.html for other OSs" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "570fd296-15a1-437d-97db-76b91407dc3c", + "execution_count": 12, + "id": "6b725d0a-e230-4b0e-b6b6-3d6d81eb984d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + } + ], + "source": [ + "from IPython.display import Audio\n", + "from optimum.intel.openvino import OVModelForAudioClassification\n", + "from transformers import AutoFeatureExtractor, pipeline\n", + "from datasets import load_dataset\n", + "\n", + "model_id = \"helenai/MIT-ast-finetuned-speech-commands-v2-ov\"\n", + "model = OVModelForAudioClassification.from_pretrained(model_id)\n", + "feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)\n", + "ov_pipe = pipeline(\"audio-classification\", model=model, feature_extractor=feature_extractor)\n", + "\n", + "# streaming=true enables loading one item from the dataset without downloading the full dataset\n", + "dataset = load_dataset(\"speech_commands\", \"v0.02\", streaming=True)\n", + "audio_sample = next(iter(dataset[\"test\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d3012174-b58f-4efb-bb73-a88dbfb20392", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:33.068965Z", - "iopub.status.busy": "2023-03-12T19:47:33.068575Z", - "iopub.status.idle": "2023-03-12T19:47:38.120307Z", - "shell.execute_reply": "2023-03-12T19:47:38.119775Z", - "shell.execute_reply.started": "2023-03-12T19:47:33.068947Z" - }, "tags": [] }, "outputs": [ @@ -532,7 +556,7 @@ "text/html": [ "\n", " \n", " " @@ -547,29 +571,28 @@ { "data": { "text/plain": [ - "[{'score': 0.9999880790710449, 'label': 'down'},\n", - " {'score': 7.452485419889854e-07, 'label': 'five'},\n", - " {'score': 7.436851205966377e-07, 'label': 'go'}]" + "[{'score': 0.9999935626983643, 'label': 'backward'},\n", + " {'score': 3.4823816008611175e-07, 'label': 'forward'},\n", + " {'score': 3.3890643180711777e-07, 'label': 'wow'}]" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from IPython.display import Audio\n", - "from optimum.intel.openvino import OVModelForAudioClassification\n", - "from transformers import AutoFeatureExtractor, pipeline\n", + "if isinstance(audio_sample, dict):\n", + " audio_data = audio_sample[\"audio\"][\"array\"]\n", + " sampling_rate = audio_sample[\"audio\"][\"sampling_rate\"]\n", + "else:\n", + " # if audio_sample is not a dataset item, it should be the path to an audio file\n", + " audio_data = audio_sample\n", + " sampling_rate = None\n", "\n", - "model_id = \"helenai/MIT-ast-finetuned-speech-commands-v2-ov\"\n", - "model = OVModelForAudioClassification.from_pretrained(model_id)\n", - "feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)\n", - "ov_pipe = pipeline(\"audio-classification\", model=model, feature_extractor=feature_extractor)\n", + "display(Audio(audio_data, rate=sampling_rate))\n", "\n", - "audio_url_or_file = \"https://datasets-server.huggingface.co/assets/speech_commands/--/v0.01/test/38/audio/audio.mp3\"\n", - "display(Audio(audio_url_or_file))\n", - "ov_pipe(audio_url_or_file, top_k=3)" + "ov_pipe(audio_data, top_k=3)" ] }, { @@ -586,16 +609,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "5207a5af-3b53-43b3-ae5e-5b352c0f08d4", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:38.121136Z", - "iopub.status.busy": "2023-03-12T19:47:38.120930Z", - "iopub.status.idle": "2023-03-12T19:47:42.382362Z", - "shell.execute_reply": "2023-03-12T19:47:42.381733Z", - "shell.execute_reply.started": "2023-03-12T19:47:38.121116Z" - }, "tags": [] }, "outputs": [ @@ -603,18 +619,20 @@ "name": "stderr", "output_type": "stream", "text": [ + "Provided model does not contain state. It may lead to sub-optimal performance.Please reexport model with updated OpenVINO version >= 2023.3.0 calling the `from_pretrained` method with original model and `export=True` parameter\n", + "Compiling the model to CPU ...\n", "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n" ] }, { "data": { "text/plain": [ - "[{'generated_text': \"Hello, I'm a language model, so you might consider changing your code to a similar type for Python 2 or 3.\\n\\nWhy Python 2\"},\n", - " {'generated_text': \"Hello, I'm a language model, so the second statement is true or true. You can also have both. It's not strictly necessary, but\"},\n", - " {'generated_text': 'Hello, I\\'m a language model, and we\\'re seeing it all in the Java world,\" he added.\\n\\nSo what might happen next?'}]" + "[{'generated_text': \"Hello, I'm a language model, so I'm really interested in programming. I've always been a programming student. But for a long time,\"},\n", + " {'generated_text': \"Hello, I'm a language model, because I don't think I ever spoke on paper to an editor. I'm simply someone reading a paper.\"},\n", + " {'generated_text': \"Hello, I'm a language model, I understand. Your mother was talking to you. No, well, my grandmother had said that she heard '\"}]" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -648,19 +666,19 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "97569002-0c0a-4208-9b63-b2bab209fb81", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:42.383244Z", - "iopub.status.busy": "2023-03-12T19:47:42.383095Z", - "iopub.status.idle": "2023-03-12T19:47:48.887705Z", - "shell.execute_reply": "2023-03-12T19:47:48.887095Z", - "shell.execute_reply.started": "2023-03-12T19:47:42.383228Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "image/jpeg": "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", @@ -674,12 +692,12 @@ { "data": { "text/plain": [ - "[{'score': 0.4759259521961212, 'label': 'flat-coated retriever'},\n", - " {'score': 0.10909564793109894, 'label': 'Labrador retriever'},\n", - " {'score': 0.08196048438549042, 'label': 'Great Dane'}]" + "[{'score': 0.4759257435798645, 'label': 'flat-coated retriever'},\n", + " {'score': 0.10909581184387207, 'label': 'Labrador retriever'},\n", + " {'score': 0.0819605216383934, 'label': 'Great Dane'}]" ] }, - "execution_count": 13, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -716,33 +734,33 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "1cd9423b-3cba-4cf9-b58a-bffbde08738d", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:48.888614Z", - "iopub.status.busy": "2023-03-12T19:47:48.888417Z", - "iopub.status.idle": "2023-03-12T19:47:52.868441Z", - "shell.execute_reply": "2023-03-12T19:47:52.867833Z", - "shell.execute_reply.started": "2023-03-12T19:47:48.888595Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "text/plain": [ - "[{'score': 0.0960492491722107,\n", + "[{'score': 0.09604837000370026,\n", " 'token': 4827,\n", " 'token_str': 'fashion',\n", " 'sequence': 'i am a fashion model'},\n", - " {'score': 0.09326528012752533,\n", + " {'score': 0.09326566755771637,\n", " 'token': 2535,\n", " 'token_str': 'role',\n", " 'sequence': 'i am a role model'}]" ] }, - "execution_count": 14, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -789,29 +807,29 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "5d9cedee-902c-41b2-b6ef-1c04bbd8498e", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:52.869399Z", - "iopub.status.busy": "2023-03-12T19:47:52.869151Z", - "iopub.status.idle": "2023-03-12T19:47:53.395475Z", - "shell.execute_reply": "2023-03-12T19:47:53.394997Z", - "shell.execute_reply.started": "2023-03-12T19:47:52.869376Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "text/plain": [ - "{'score': 0.5305245518684387,\n", + "{'score': 0.5305243730545044,\n", " 'start': 12,\n", " 'end': 75,\n", " 'answer': 'an open source toolkit for deep learning inference optimization'}" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -845,26 +863,28 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "id": "755096b0-406d-4167-8642-5b4b093e2bc5", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:47:53.396122Z", - "iopub.status.busy": "2023-03-12T19:47:53.395987Z", - "iopub.status.idle": "2023-03-12T19:48:00.052492Z", - "shell.execute_reply": "2023-03-12T19:48:00.052125Z", - "shell.execute_reply.started": "2023-03-12T19:47:53.396109Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the encoder to CPU ...\n", + "Compiling the decoder to CPU ...\n", + "Compiling the decoder to CPU ...\n" + ] + }, { "data": { "text/plain": [ "'Das Haus ist wunderbar.'" ] }, - "execution_count": 16, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -884,16 +904,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "id": "c0f096f2-0cd3-40ab-9661-1c7209c6a670", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:48:00.053145Z", - "iopub.status.busy": "2023-03-12T19:48:00.052965Z", - "iopub.status.idle": "2023-03-12T19:48:00.056985Z", - "shell.execute_reply": "2023-03-12T19:48:00.056530Z", - "shell.execute_reply.started": "2023-03-12T19:48:00.053133Z" - }, "tags": [] }, "outputs": [ @@ -906,7 +919,7 @@ " 'translation_en_to_ro']" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -918,16 +931,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "id": "ebf97e9c-d1e1-4908-8a3a-bad24ee3a34f", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:48:00.057929Z", - "iopub.status.busy": "2023-03-12T19:48:00.057694Z", - "iopub.status.idle": "2023-03-12T19:48:00.399891Z", - "shell.execute_reply": "2023-03-12T19:48:00.399417Z", - "shell.execute_reply.started": "2023-03-12T19:48:00.057914Z" - }, "tags": [] }, "outputs": [ @@ -937,7 +943,7 @@ "[{'translation_text': \"Qu'est-ce qu'un modèle de séquence à séquence?\"}]" ] }, - "execution_count": 18, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -967,26 +973,26 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "id": "59df852f-e9bb-4f96-91d9-23f4e4577ea0", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:48:00.400753Z", - "iopub.status.busy": "2023-03-12T19:48:00.400401Z", - "iopub.status.idle": "2023-03-12T19:48:04.459054Z", - "shell.execute_reply": "2023-03-12T19:48:04.458437Z", - "shell.execute_reply.started": "2023-03-12T19:48:00.400729Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "data": { "text/plain": [ "[{'label': 'nl', 'score': 0.994126558303833}]" ] }, - "execution_count": 19, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1018,19 +1024,19 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "id": "87f633c0-3334-4ef0-942a-5bdec807568d", "metadata": { - "execution": { - "iopub.execute_input": "2023-03-12T19:48:04.459956Z", - "iopub.status.busy": "2023-03-12T19:48:04.459670Z", - "iopub.status.idle": "2023-03-12T19:48:07.863986Z", - "shell.execute_reply": "2023-03-12T19:48:07.863615Z", - "shell.execute_reply.started": "2023-03-12T19:48:04.459935Z" - }, "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling the model to CPU ...\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -1070,6 +1076,14 @@ "- Notebook: [Post Training Quantization of a question-answering model](https://github.com/huggingface/optimum-intel/blob/main/notebooks/openvino/question_answering_quantization.ipynb)\n", "- Examples: [Quantization Aware Training examples](https://github.com/huggingface/optimum-intel/tree/main/examples/openvino)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0606fb02-2367-4573-8461-7fc8c065ece6", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1088,7 +1102,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.12" }, "widgets": { "application/vnd.jupyter.widget-state+json": { diff --git a/notebooks/openvino/question_answering_quantization.ipynb b/notebooks/openvino/question_answering_quantization.ipynb index 782a48ff45..ba4a84ca38 100644 --- a/notebooks/openvino/question_answering_quantization.ipynb +++ b/notebooks/openvino/question_answering_quantization.ipynb @@ -846,9 +846,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "FP32 model size: 436.07 MB\n", - "INT8 model size: 182.41 MB\n", - "INT8 size decrease: 2.39x\n" + "FP32 model size: 436.50 MB\n", + "INT8 model size: 181.84 MB\n", + "INT8 size decrease: 2.4x\n" ] } ], @@ -858,7 +858,7 @@ " Return OpenVINO or PyTorch model size in Mb.\n", " Arguments:\n", " model_folder:\n", - " Directory containing a pytorch_model.bin for a PyTorch model, and an openvino_model.xml/.bin for an OpenVINO model.\n", + " Directory containing a model.safetensors for a PyTorch model, and an openvino_model.xml/.bin for an OpenVINO model.\n", " framework:\n", " Define whether the model is a PyTorch or an OpenVINO model.\n", " \"\"\"\n", @@ -866,7 +866,7 @@ " model_path = Path(model_folder) / \"openvino_model.xml\"\n", " model_size = model_path.stat().st_size + model_path.with_suffix(\".bin\").stat().st_size\n", " elif framework.lower() == \"pytorch\":\n", - " model_path = Path(model_folder) / \"pytorch_model.bin\"\n", + " model_path = Path(model_folder) / \"model.safetensors\"\n", " model_size = model_path.stat().st_size\n", " model_size /= 1000 * 1000\n", " return model_size\n",