From 608bfb521dca02fe11ada707ad4ed58f917c592f Mon Sep 17 00:00:00 2001
From: zsszabo <zsolt.szabo@evosoft.com>
Date: Tue, 3 Dec 2024 15:36:38 +0100
Subject: [PATCH] reverting spaces

---
 .../notebooks/40-TestPipelineLocally.ipynb    | 230 ++++----
 .../notebooks/30-CreatePipelinePackage.ipynb  | 510 ++++++++---------
 .../notebooks/40-TestPipelineLocally.ipynb    | 334 +++++------
 .../keras-to-onnx/keras-to-onnx.ipynb         | 516 ++++++++---------
 .../pytorch-to-onnx/pytorch-to-onnx.ipynb     | 526 +++++++++---------
 5 files changed, 1058 insertions(+), 1058 deletions(-)

diff --git a/e2e-tutorials/batch_state_identifier/notebooks/40-TestPipelineLocally.ipynb b/e2e-tutorials/batch_state_identifier/notebooks/40-TestPipelineLocally.ipynb
index 67f7e10..64e3f61 100644
--- a/e2e-tutorials/batch_state_identifier/notebooks/40-TestPipelineLocally.ipynb
+++ b/e2e-tutorials/batch_state_identifier/notebooks/40-TestPipelineLocally.ipynb
@@ -1,118 +1,118 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
-    "SPDX-License-Identifier": "MIT"
-   },
-   "source": [
-    "# Testing the edge configuration package\n",
-    "\n",
-    "In this notebook, the main goal is to test the edge configuration package created in notebook [30-CreatePipelinePackage](30-CreatePipelinePackage.ipynb)\n",
-    "driving it with the training data set which was used in notebook [10-CreateModel](10-CreateModel.ipynb).\n",
-    "\n",
-    "The `LocalPipelineRunner` object takes the edge configuration package and extracts its components.\n",
-    "Once the components are extracted, you can run them individually by calling `run_component` with component name and structured input data.\n",
-    "The method builds a `venv` Python virtual environment for running the component and installs the required dependencies listed in `requirements.txt` for the component.\n",
-    "Once the virtual python environment is ready, the method executes and feeds the component with your test data.\n",
-    "The result will be the list of outputs of your component. If your component does not always produce an output, as is the case with a preprocessor aggregating a windowful of data, the output list will be shorter than the input list."
-   ]
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
+        "SPDX-License-Identifier": "MIT"
+      },
+      "source": [
+        "# Testing the edge configuration package\n",
+        "\n",
+        "In this notebook, the main goal is to test the edge configuration package created in notebook [30-CreatePipelinePackage](30-CreatePipelinePackage.ipynb)\n",
+        "driving it with the training data set which was used in notebook [10-CreateModel](10-CreateModel.ipynb).\n",
+        "\n",
+        "The `LocalPipelineRunner` object takes the edge configuration package and extracts its components.\n",
+        "Once the components are extracted, you can run them individually by calling `run_component` with component name and structured input data.\n",
+        "The method builds a `venv` Python virtual environment for running the component and installs the required dependencies listed in `requirements.txt` for the component.\n",
+        "Once the virtual python environment is ready, the method executes and feeds the component with your test data.\n",
+        "The result will be the list of outputs of your component. If your component does not always produce an output, as is the case with a preprocessor aggregating a windowful of data, the output list will be shorter than the input list."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Define a dataset to test the package\n",
+        "The goal here is to create a list of input data which the `process_input(data: dict)` method will be triggered with.  \n",
+        "For this reason, we read the json files and create the list of payloads as we did in notebook [10-CreateModel](10-CreateModel.ipynb)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import json\n",
+        "from pathlib import Path\n",
+        "\n",
+        "json_files = Path('../data/processed/example').glob('*.json')\n",
+        "inputs = []\n",
+        "for json_file in json_files:\n",
+        "    with open(json_file) as f:\n",
+        "        json_string = json.load(f)\n",
+        "        inputs.append({'json_data': json.dumps(json_string)})"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Test the pipeline locally\n",
+        "To do so we instantiate a `LocalPipelineRunner` object with the path of our configuration package, and a directory where we want to check the results.\n",
+        "This directory will contain both the extracted component and the created python virtual environment.\n",
+        "If the directory is not defined, a temporary directory is created and deleted after testing."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": []
+      },
+      "outputs": [],
+      "source": [
+        "from simaticai.testing.pipeline_runner import LocalPipelineRunner\n",
+        "\n",
+        "test_dir = Path('../test')\n",
+        "package_path = Path('../packages/Batch-State-Identifier-edge_1.zip')\n",
+        "\n",
+        "output = []\n",
+        "with LocalPipelineRunner(package_path, test_dir) as pipelineRunner:\n",
+        "    output = pipelineRunner.run_pipeline(inputs)  "
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Check the results\n",
+        "The method returns with the calculated results which can be compared to the expected result."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "output"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": " Python (batch_state_identifier)",
+      "language": "python",
+      "name": "batch_state_identifier"
+    },
+    "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.11.9"
+    }
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Define a dataset to test the package\n",
-    "The goal here is to create a list of input data which the `process_input(data: dict)` method will be triggered with.  \n",
-    "For this reason, we read the json files and create the list of payloads as we did in notebook [10-CreateModel](10-CreateModel.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "from pathlib import Path\n",
-    "\n",
-    "json_files = Path('../data/processed/example').glob('*.json')\n",
-    "inputs = []\n",
-    "for json_file in json_files:\n",
-    "    with open(json_file) as f:\n",
-    "        json_string = json.load(f)\n",
-    "        inputs.append({'json_data': json.dumps(json_string)})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Test the pipeline locally\n",
-    "To do so we instantiate a `LocalPipelineRunner` object with the path of our configuration package, and a directory where we want to check the results.\n",
-    "This directory will contain both the extracted component and the created python virtual environment.\n",
-    "If the directory is not defined, a temporary directory is created and deleted after testing."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from simaticai.testing.pipeline_runner import LocalPipelineRunner\n",
-    "\n",
-    "test_dir = Path('../test')\n",
-    "package_path = Path('../packages/Batch-State-Identifier-edge_1.zip')\n",
-    "\n",
-    "output = []\n",
-    "with LocalPipelineRunner(package_path, test_dir) as pipelineRunner:\n",
-    "    output = pipelineRunner.run_pipeline(inputs)  "
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Check the results\n",
-    "The method returns with the calculated results which can be compared to the expected result."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "output"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": " Python (batch_state_identifier)",
-   "language": "python",
-   "name": "batch_state_identifier"
-  },
-  "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 4
 }
diff --git a/e2e-tutorials/image_classification/notebooks/30-CreatePipelinePackage.ipynb b/e2e-tutorials/image_classification/notebooks/30-CreatePipelinePackage.ipynb
index 50ced98..f88e39a 100644
--- a/e2e-tutorials/image_classification/notebooks/30-CreatePipelinePackage.ipynb
+++ b/e2e-tutorials/image_classification/notebooks/30-CreatePipelinePackage.ipynb
@@ -1,258 +1,258 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
-    "SPDX-License-Identifier": "MIT"
-   },
-   "source": [
-    "# Create a TensorFlow Lite edge configuration package\n",
-    "\n",
-    "In this notebook, the main goal is to create a pipeline with all of the contents that are necessary for the execution of the model on an Industrial Edge device.  \n",
-    "In order to put the elements together, this example collects files\n",
-    "\n",
-    "from [10-CreateClassificationModel](10-CreateClassificationModel.ipynb) notebook:  \n",
-    "- **classification_mobilnet.tflite**: the trained model for classification with TFlite\n",
-    "\n",
-    "from [20-CreateInferenceWrapper](20-CreateInferenceWrapper.ipynb) notebook:  \n",
-    "- **entrypoint.py**: the script that is called by the runtime to execute the model on the Edge side\n",
-    "- **payload.py**: contains the method which extracts the payload and create a PIL Image to be processed\n",
-    "- **vision_classifier.py**: contains the method to utilize the model and produces a prediction"
-   ]
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
+        "SPDX-License-Identifier": "MIT"
+      },
+      "source": [
+        "# Create a TensorFlow Lite edge configuration package\n",
+        "\n",
+        "In this notebook, the main goal is to create a pipeline with all of the contents that are necessary for the execution of the model on an Industrial Edge device.  \n",
+        "In order to put the elements together, this example collects files\n",
+        "\n",
+        "from [10-CreateClassificationModel](10-CreateClassificationModel.ipynb) notebook:  \n",
+        "- **classification_mobilnet.tflite**: the trained model for classification with TFlite\n",
+        "\n",
+        "from [20-CreateInferenceWrapper](20-CreateInferenceWrapper.ipynb) notebook:  \n",
+        "- **entrypoint.py**: the script that is called by the runtime to execute the model on the Edge side\n",
+        "- **payload.py**: contains the method which extracts the payload and create a PIL Image to be processed\n",
+        "- **vision_classifier.py**: contains the method to utilize the model and produces a prediction"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Please note, there is no official TFLite runtime for Windows."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Imports  "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from simaticai import deployment"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a single component\n",
+        "\n",
+        "In this step, we create a `PythonComponent` that reads the input data `vision_payload` by `entrypoint.py`, processes the images by `vision_classifier.py` with model `classification_mobilnet.tflite` and produces an output `prediction` by `entrypoint.py` script."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "COMPONENT_DESCRIPTION =\"\"\"\\\n",
+        "This component uses a trained TensorFlow Lite image classification model that reads the vision_payload input and produces a prediction as an output.\n",
+        "\"\"\"\n",
+        "INPUT_DESCRIPTION =\"\"\"\n",
+        "Vision connector MQTT payload holding the image to be classified.\n",
+        "\"\"\"\n",
+        "OUTPUT_DESCRIPTION =\"\"\"\n",
+        "The most probable class predicted for the image as an integer string.\n",
+        "\"\"\"\n",
+        "\n",
+        "component = deployment.PythonComponent(\n",
+        "    name='inference', \n",
+        "    python_version='3.11',\n",
+        "    desc=COMPONENT_DESCRIPTION)\n",
+        "\n",
+        "component.add_resources('..', 'entrypoint.py')\n",
+        "component.set_entrypoint('entrypoint.py')\n",
+        "component.add_resources('..', ['src/payload.py', 'src/vision_classifier.py'])\n",
+        "\n",
+        "component.add_input('vision_payload', 'ImageSet')\n",
+        "component.add_output('prediction', 'String')"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Add metrics\n",
+        "It can be useful to monitor the pipeline, e.g. watch the prediction probabilities. The metric name must contain an underscore (`_`), because the part before the underscore is used to group custom metrics on the dashboard.\n",
+        "\n",
+        "**&#9888; Remember!**\n",
+        "You have to use the same names here and in the inference wrapper script."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "component.add_metric(\"ic_probability\")"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Add dependencies\n",
+        "\n",
+        "All of the required dependencies are collected in the file `runtime_requirements.txt`. See [How to handle Python dependencies](../../../howto-guides/04-handle-python-dependencies.md) for more possibilities."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "component.set_requirements('../runtime_requirements-py3.11.txt')"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Add a model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "component.add_resources('..', 'models/classification_mobilnet.tflite')"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Create a pipeline from this component\n",
+        "\n",
+        "Now you can use the component to create a pipeline configuration.  "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "testinit_package_name"
+        ]
+      },
+      "outputs": [],
+      "source": [
+        "PIPELINE_DESCRIPTION =\"\"\"\\\n",
+        "This pipeline runs a TensorFlow Lite model on an Industrial Edge device.\n",
+        "The model was trained to recognize and classify images of following Siemens SIMATIC automation products: ET 200AL, ET 200eco PN, ET 200SP, S7-1200, S7-1500.\n",
+        "\n",
+        "The pipeline is designed to be fed from Vision Connector via Databus with PNG or JPEG type images.\n",
+        "The pipeline output is to be sent to the Databus.\n",
+        "\"\"\"\n",
+        "\n",
+        "#To assure compatibility with older versions of AI SDK (<v1.5.0), you must define the `version` parameter in the `from_components()` method\n",
+        "pipeline = deployment.Pipeline.from_components([component], name='ImageClassification', desc=PIPELINE_DESCRIPTION)\n",
+        "pipeline"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Build the edge configuration package\n",
+        "\n",
+        "This step creates the proper content in the defined target folder and creates the edge configuration package as a zip file.  \n",
+        "The export method first validates the pipeline and raises an error if it finds any problems. Manual validation is also possible with the `pipeline.validate()` method.\n",
+        "\n",
+        "Edge packages are identified by their `package id` and `version` attributes, and will be grouped in AI Inference Server and in other Edge applications by `package id`.\n",
+        "When saving a pipeline - in the `export()` method - you can specify a `pacakge id` in a UUID 4 compliant format, or an automatically generated one will be assigned. \n",
+        "If no `package id` is defined in the `export()` method, and AI SDK finds an already assigned `package id` in a previously generated, and similarly named package, the `package id` found in the latest package will be used.\n",
+        "\n",
+        "AI SDK will automatically assign and increase the version number of a pipeline every time a package is saved, unless a new package id is assigned in the `export()` method or an explicit version number is defined without package id either in the `export()` method or in the pipeline constructor.\n",
+        "\n",
+        "Restrictions: \n",
+        "- You can not overwrite a previously saved package with the same `package id` if the `package id` is explicitly assigned in the `export()` method \n",
+        "- Packages generated with older versions of AI SDK (without `package id`) will be overwritten\n",
+        "- If a new `package id` is assigned to an existing version of the package it will overwrite the old one\n",
+        "- If no previous version of a package (with a generated or explicitly assigned `package id`) found, AI SDK will assign the version `1` to the created package\n",
+        "- Version defined in the `export()` method takes precedence over the version assigned on constructor level\n",
+        "\n",
+        "Now you are ready to bring your model to the shopfloor by building the edge configuration package from the pipeline configuration. You can achieve this by the following step."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "edge_package_path = pipeline.export(destination = '../packages')\n",
+        "edge_package_path"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Test the edge configuration package locally\n",
+        "\n",
+        "We suggest you test your edge configuration package on your computer before deploying it to an Edge device. It is possible to do so using notebook [40-TestPipelineLocally.ipynb](40-TestPipelineLocally.ipynb)."
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Test the edge configuration package in AI Inference Server\n",
+        "\n",
+        "If you also have dockerized Edge environment on your computer, why not try your package with how-to guide [22-test-on-edge-device](../../../howto-guides/22-test-on-edge-device.md)?  \n",
+        "This test can most accurately prove the validity of your package."
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python (image_classification)",
+      "language": "python",
+      "name": "image_classification"
+    },
+    "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.11.9"
+    }
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Please note, there is no official TFLite runtime for Windows."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Imports  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from simaticai import deployment"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create a single component\n",
-    "\n",
-    "In this step, we create a `PythonComponent` that reads the input data `vision_payload` by `entrypoint.py`, processes the images by `vision_classifier.py` with model `classification_mobilnet.tflite` and produces an output `prediction` by `entrypoint.py` script."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "COMPONENT_DESCRIPTION =\"\"\"\\\n",
-    "This component uses a trained TensorFlow Lite image classification model that reads the vision_payload input and produces a prediction as an output.\n",
-    "\"\"\"\n",
-    "INPUT_DESCRIPTION =\"\"\"\n",
-    "Vision connector MQTT payload holding the image to be classified.\n",
-    "\"\"\"\n",
-    "OUTPUT_DESCRIPTION =\"\"\"\n",
-    "The most probable class predicted for the image as an integer string.\n",
-    "\"\"\"\n",
-    "\n",
-    "component = deployment.PythonComponent(\n",
-    "    name='inference', \n",
-    "    python_version='3.11',\n",
-    "    desc=COMPONENT_DESCRIPTION)\n",
-    "\n",
-    "component.add_resources('..', 'entrypoint.py')\n",
-    "component.set_entrypoint('entrypoint.py')\n",
-    "component.add_resources('..', ['src/payload.py', 'src/vision_classifier.py'])\n",
-    "\n",
-    "component.add_input('vision_payload', 'ImageSet')\n",
-    "component.add_output('prediction', 'String')"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Add metrics\n",
-    "It can be useful to monitor the pipeline, e.g. watch the prediction probabilities. The metric name must contain an underscore (`_`), because the part before the underscore is used to group custom metrics on the dashboard.\n",
-    "\n",
-    "**&#9888; Remember!**\n",
-    "You have to use the same names here and in the inference wrapper script."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "component.add_metric(\"ic_probability\")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Add dependencies\n",
-    "\n",
-    "All of the required dependencies are collected in the file `runtime_requirements.txt`. See [How to handle Python dependencies](../../../howto-guides/04-handle-python-dependencies.md) for more possibilities."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "component.set_requirements('../runtime_requirements-py3.11.txt')"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Add a model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "component.add_resources('..', 'models/classification_mobilnet.tflite')"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create a pipeline from this component\n",
-    "\n",
-    "Now you can use the component to create a pipeline configuration.  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": [
-     "testinit_package_name"
-    ]
-   },
-   "outputs": [],
-   "source": [
-    "PIPELINE_DESCRIPTION =\"\"\"\\\n",
-    "This pipeline runs a TensorFlow Lite model on an Industrial Edge device.\n",
-    "The model was trained to recognize and classify images of following Siemens SIMATIC automation products: ET 200AL, ET 200eco PN, ET 200SP, S7-1200, S7-1500.\n",
-    "\n",
-    "The pipeline is designed to be fed from Vision Connector via Databus with PNG or JPEG type images.\n",
-    "The pipeline output is to be sent to the Databus.\n",
-    "\"\"\"\n",
-    "\n",
-    "#To assure compatibility with older versions of AI SDK (<v1.5.0), you must define the `version` parameter in the `from_components()` method\n",
-    "pipeline = deployment.Pipeline.from_components([component], name='ImageClassification', desc=PIPELINE_DESCRIPTION)\n",
-    "pipeline"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Build the edge configuration package\n",
-    "\n",
-    "This step creates the proper content in the defined target folder and creates the edge configuration package as a zip file.  \n",
-    "The export method first validates the pipeline and raises an error if it finds any problems. Manual validation is also possible with the `pipeline.validate()` method.\n",
-    "\n",
-    "Edge packages are identified by their `package id` and `version` attributes, and will be grouped in AI Inference Server and in other Edge applications by `package id`.\n",
-    "When saving a pipeline - in the `export()` method - you can specify a `pacakge id` in a UUID 4 compliant format, or an automatically generated one will be assigned. \n",
-    "If no `package id` is defined in the `export()` method, and AI SDK finds an already assigned `package id` in a previously generated, and similarly named package, the `package id` found in the latest package will be used.\n",
-    "\n",
-    "AI SDK will automatically assign and increase the version number of a pipeline every time a package is saved, unless a new package id is assigned in the `export()` method or an explicit version number is defined without package id either in the `export()` method or in the pipeline constructor.\n",
-    "\n",
-    "Restrictions: \n",
-    "- You can not overwrite a previously saved package with the same `package id` if the `package id` is explicitly assigned in the `export()` method \n",
-    "- Packages generated with older versions of AI SDK (without `package id`) will be overwritten\n",
-    "- If a new `package id` is assigned to an existing version of the package it will overwrite the old one\n",
-    "- If no previous version of a package (with a generated or explicitly assigned `package id`) found, AI SDK will assign the version `1` to the created package\n",
-    "- Version defined in the `export()` method takes precedence over the version assigned on constructor level\n",
-    "\n",
-    "Now you are ready to bring your model to the shopfloor by building the edge configuration package from the pipeline configuration. You can achieve this by the following step."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "edge_package_path = pipeline.export(destination = '../packages')\n",
-    "edge_package_path"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Test the edge configuration package locally\n",
-    "\n",
-    "We suggest you test your edge configuration package on your computer before deploying it to an Edge device. It is possible to do so using notebook [40-TestPipelineLocally.ipynb](40-TestPipelineLocally.ipynb)."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Test the edge configuration package in AI Inference Server\n",
-    "\n",
-    "If you also have dockerized Edge environment on your computer, why not try your package with how-to guide [22-test-on-edge-device](../../../howto-guides/22-test-on-edge-device.md)?  \n",
-    "This test can most accurately prove the validity of your package."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python (image_classification)",
-   "language": "python",
-   "name": "image_classification"
-  },
-  "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 4
 }
diff --git a/e2e-tutorials/object_detection/notebooks/40-TestPipelineLocally.ipynb b/e2e-tutorials/object_detection/notebooks/40-TestPipelineLocally.ipynb
index 4b0a13b..40f5f35 100644
--- a/e2e-tutorials/object_detection/notebooks/40-TestPipelineLocally.ipynb
+++ b/e2e-tutorials/object_detection/notebooks/40-TestPipelineLocally.ipynb
@@ -1,170 +1,170 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
-    "SPDX-License-Identifier": "MIT"
-   },
-   "source": [
-    "# Test the edge configuration package locally"
-   ]
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
+        "SPDX-License-Identifier": "MIT"
+      },
+      "source": [
+        "# Test the edge configuration package locally"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This notebook introduces you how to execute a created Pipeline in your local Python environment.  \n",
+        "During its execution, an `ImageSet` payload is created from images, as we discussed in the notebook [20-PreAndPostProcessing.ipynb](./20-PreAndPostProcessing.ipynb) and uses the Pipeline we created in notebook [30-CreatePipeline.ipynb](./30-CreatePipeline.ipynb).\n",
+        "\n",
+        "The main goal to understand \n",
+        "- how the test inputs are formed, \n",
+        "- how the PythonComponent test environment is created\n",
+        "- how the GPURuntimeComponent test environment is created\n",
+        "- how to check the Pipeline behaviour"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Create ImageSet input from a JPEG or PNG file\n",
+        "\n",
+        "As we discussed in notebook [](./20-PreAndPostProcessing.ipynb), the payload of the Pipeline is an `ImageSet` in a dictionary, which will be processed by the Preprocessing step. For this reason, we create this payload from images in folder _../src/data/processed_ with the help of method defined in notebook [10-ObjectDetectionModel.ipynb](./10-ObjectDetectionModel.ipynb) and saved into Python script [payload.py](../src/preprocessing/payload.py)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from pathlib import Path\n",
+        "import sys\n",
+        "\n",
+        "sys.path.append('../src/')\n",
+        "from preprocessing.payload import create_imageset_dict"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Create the required input format from an input JPG file using the method _create_imageset_dict_."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "data_path = Path(\"../data/processed/\")\n",
+        "files = list(str(f) for f in data_path.rglob(\"*.jpg\"))\n",
+        "\n",
+        "pipeline_inputs = []\n",
+        "for image_file in files:\n",
+        "    image_set = create_imageset_dict(image_file, \"BayerRG8\")\n",
+        "    pipeline_inputs.append({ \"vision_payload\": image_set})\n",
+        "\n",
+        "len(pipeline_inputs), pipeline_inputs[:1]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Test the pipeline configuration package locally\n",
+        "Take the created _pipeline_inputs_ to be tested as input of the `LocalPipelineRunner`, and run the pipeline with the test data.\n",
+        "The `LocalPipelineRunner` module is designed to be used __only__ inside a `with` block.\n",
+        "\n",
+        "The `run_pipeline` method can be called multiple times but be aware that the internal state of the components is reset between the calls. Use batch input if you want to keep the state between inputs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from random import randint\n",
+        "from simaticai.testing.pipeline_runner import LocalPipelineRunner\n",
+        "\n",
+        "image_on_edge_package = Path('../packages/BoardObjectDetection-edge_1.zip')\n",
+        "test_dir = Path(\"..\").resolve() / \"test\"\n",
+        "\n",
+        "pipeline_outputs = []\n",
+        "with LocalPipelineRunner(image_on_edge_package, test_dir) as runner:\n",
+        "    for i in range(10):\n",
+        "        pipeline_output = runner.run_pipeline(pipeline_inputs[randint(0, len(pipeline_inputs) - 1)])\n",
+        "        pipeline_outputs.append(pipeline_output)\n",
+        "\n",
+        "pipeline_outputs"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### Test Pipeline step by step\n",
+        "\n",
+        "In case of any issue occurs, there is an option to test the Pipeline by Components.  \n",
+        "Here we use the `run_component` method of `LocalPipelineRunner` instead of `run_pipeline`. In this case there are three Steps in the Pipeline, one for GPURuntimeComponent and two for PythonComponents. This way the inputs and outputs can be investigated independently, or you can execute only one step of the Pipeline, defining only the expected input of that Pipeline step.\n",
+        "The main difference between the two type of steps is the Python environment created for them to execute.  \n",
+        "While the test environment for a `PythonComponent` is created from the base environment by installing the defined Python packages defined in the requirements.txt of the component, the test environment for a `GPURuntimeComponent` installs only those Python packages, which are required to execute an ONNX model. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "image_on_edge_package = Path('../packages/BoardObjectDetection-edge_1.zip')\n",
+        "test_dir = Path(\"..\").resolve() / \"test\"\n",
+        "\n",
+        "with LocalPipelineRunner(image_on_edge_package, test_dir) as runner:\n",
+        "    preprocessing_output  = runner.run_component(\"preprocessing\", pipeline_inputs)\n",
+        "\n",
+        "    detection_output = runner.run_component(\"detection\", preprocessing_output)\n",
+        "    \n",
+        "    postprocessing_output = runner.run_component(\"postprocessing\", detection_output)\n",
+        "\n",
+        "preprocessing_output, detection_output, postprocessing_output"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Once the expected outputs can be generated here, you are ready to step one further and give the Pipeline a try on `AI Inference Server`.\n",
+        "The main differences on the real device are\n",
+        "- underlying CPU, GPU configuration\n",
+        "- underlying Operating System\n",
+        "- used Python packages"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "(Python) Object Detection",
+      "language": "python",
+      "name": "object_detection"
+    },
+    "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.11.9"
+    }
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This notebook introduces you how to execute a created Pipeline in your local Python environment.  \n",
-    "During its execution, an `ImageSet` payload is created from images, as we discussed in the notebook [20-PreAndPostProcessing.ipynb](./20-PreAndPostProcessing.ipynb) and uses the Pipeline we created in notebook [30-CreatePipeline.ipynb](./30-CreatePipeline.ipynb).\n",
-    "\n",
-    "The main goal to understand \n",
-    "- how the test inputs are formed, \n",
-    "- how the PythonComponent test environment is created\n",
-    "- how the GPURuntimeComponent test environment is created\n",
-    "- how to check the Pipeline behaviour"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Create ImageSet input from a JPEG or PNG file\n",
-    "\n",
-    "As we discussed in notebook [](./20-PreAndPostProcessing.ipynb), the payload of the Pipeline is an `ImageSet` in a dictionary, which will be processed by the Preprocessing step. For this reason, we create this payload from images in folder _../src/data/processed_ with the help of method defined in notebook [10-ObjectDetectionModel.ipynb](./10-ObjectDetectionModel.ipynb) and saved into Python script [payload.py](../src/preprocessing/payload.py)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "import sys\n",
-    "\n",
-    "sys.path.append('../src/')\n",
-    "from preprocessing.payload import create_imageset_dict"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create the required input format from an input JPG file using the method _create_imageset_dict_."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_path = Path(\"../data/processed/\")\n",
-    "files = list(str(f) for f in data_path.rglob(\"*.jpg\"))\n",
-    "\n",
-    "pipeline_inputs = []\n",
-    "for image_file in files:\n",
-    "    image_set = create_imageset_dict(image_file, \"BayerRG8\")\n",
-    "    pipeline_inputs.append({ \"vision_payload\": image_set})\n",
-    "\n",
-    "len(pipeline_inputs), pipeline_inputs[:1]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Test the pipeline configuration package locally\n",
-    "Take the created _pipeline_inputs_ to be tested as input of the `LocalPipelineRunner`, and run the pipeline with the test data.\n",
-    "The `LocalPipelineRunner` module is designed to be used __only__ inside a `with` block.\n",
-    "\n",
-    "The `run_pipeline` method can be called multiple times but be aware that the internal state of the components is reset between the calls. Use batch input if you want to keep the state between inputs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from random import randint\n",
-    "from simaticai.testing.pipeline_runner import LocalPipelineRunner\n",
-    "\n",
-    "image_on_edge_package = Path('../packages/BoardObjectDetection-edge_1.zip')\n",
-    "test_dir = Path(\"..\").resolve() / \"test\"\n",
-    "\n",
-    "pipeline_outputs = []\n",
-    "with LocalPipelineRunner(image_on_edge_package, test_dir) as runner:\n",
-    "    for i in range(10):\n",
-    "        pipeline_output = runner.run_pipeline(pipeline_inputs[randint(0, len(pipeline_inputs) - 1)])\n",
-    "        pipeline_outputs.append(pipeline_output)\n",
-    "\n",
-    "pipeline_outputs"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Test Pipeline step by step\n",
-    "\n",
-    "In case of any issue occurs, there is an option to test the Pipeline by Components.  \n",
-    "Here we use the `run_component` method of `LocalPipelineRunner` instead of `run_pipeline`. In this case there are three Steps in the Pipeline, one for GPURuntimeComponent and two for PythonComponents. This way the inputs and outputs can be investigated independently, or you can execute only one step of the Pipeline, defining only the expected input of that Pipeline step.\n",
-    "The main difference between the two type of steps is the Python environment created for them to execute.  \n",
-    "While the test environment for a `PythonComponent` is created from the base environment by installing the defined Python packages defined in the requirements.txt of the component, the test environment for a `GPURuntimeComponent` installs only those Python packages, which are required to execute an ONNX model. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image_on_edge_package = Path('../packages/BoardObjectDetection-edge_1.zip')\n",
-    "test_dir = Path(\"..\").resolve() / \"test\"\n",
-    "\n",
-    "with LocalPipelineRunner(image_on_edge_package, test_dir) as runner:\n",
-    "    preprocessing_output  = runner.run_component(\"preprocessing\", pipeline_inputs)\n",
-    "\n",
-    "    detection_output = runner.run_component(\"detection\", preprocessing_output)\n",
-    "    \n",
-    "    postprocessing_output = runner.run_component(\"postprocessing\", detection_output)\n",
-    "\n",
-    "preprocessing_output, detection_output, postprocessing_output"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Once the expected outputs can be generated here, you are ready to step one further and give the Pipeline a try on `AI Inference Server`.\n",
-    "The main differences on the real device are\n",
-    "- underlying CPU, GPU configuration\n",
-    "- underlying Operating System\n",
-    "- used Python packages"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "(Python) Object Detection",
-   "language": "python",
-   "name": "object_detection"
-  },
-  "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 4
 }
diff --git a/howto-notebooks/model-conversion/keras-to-onnx/keras-to-onnx.ipynb b/howto-notebooks/model-conversion/keras-to-onnx/keras-to-onnx.ipynb
index d6bc4f9..d2943e6 100644
--- a/howto-notebooks/model-conversion/keras-to-onnx/keras-to-onnx.ipynb
+++ b/howto-notebooks/model-conversion/keras-to-onnx/keras-to-onnx.ipynb
@@ -1,261 +1,261 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
-    "SPDX-License-Identifier": "MIT"
-   },
-   "source": [
-    "# Model Conversion for Keras models\n",
-    "\n",
-    "This tutorial explains how to convert a Keras Model stored in tensorflow's 'h5' format to a standardized ONNX format, which enables you to run your model on a GPU enabled AI Inference Server.  \n",
-    "\n",
-    "In this tutorial you learn how to \n",
-    "- load a model in 'h5' format\n",
-    "- convert and save the loaded model into 'onnx' format\n",
-    "- verify the input and output shape of the model\n"
-   ]
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
+        "SPDX-License-Identifier": "MIT"
+      },
+      "source": [
+        "# Model Conversion for Keras models\n",
+        "\n",
+        "This tutorial explains how to convert a Keras Model stored in tensorflow's 'h5' format to a standardized ONNX format, which enables you to run your model on a GPU enabled AI Inference Server.  \n",
+        "\n",
+        "In this tutorial you learn how to \n",
+        "- load a model in 'h5' format\n",
+        "- convert and save the loaded model into 'onnx' format\n",
+        "- verify the input and output shape of the model\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the model\n",
+        "\n",
+        "For this model conversion tutorial we are going to use the same model we created and trained in our [Image Classification](../../../e2e-tutorials/image_classification/README.md) example."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from pathlib import Path\n",
+        "import tensorflow as tf\n",
+        "import sys\n",
+        "\n",
+        "PYTHON_VERSION = sys.version_info\n",
+        "\n",
+        "if PYTHON_VERSION.minor == 11:\n",
+        "    model_path = Path('./models/classification_mobilnet-py311.h5')\n",
+        "else:\n",
+        "    model_path = Path('./models/classification_mobilnet-py310.h5')\n",
+        "\n",
+        "model = tf.keras.models.load_model(model_path)\n",
+        "model"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Convert and Save\n",
+        "\n",
+        "In order to be able to convert your keras model to ONNX, you need to know the input shape and type of your model.  \n",
+        "These are stored in the properties of the original model as:\n",
+        "\n",
+        "- `model.input.shape`, and\n",
+        "- `model.input.dtype`\n",
+        "\n",
+        "Using these two, we can create an `input_signature` as `tensorflow.TensorSpec` class.  \n",
+        "In the constructor of TensorSpec you can define the `name` of the input tensor. In this tutorial, we are setting the `name` of the input tensor as `input`.  \n",
+        "Parameter `opset` defines the version of the `ONNX format`, opset version `13` refers to ONNX format `1.8.0` which is supported by AI Inference Server at the time of writing."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import tf2onnx\n",
+        "import onnx\n",
+        "import tensorflow as tf\n",
+        "    \n",
+        "if PYTHON_VERSION.minor == 11:\n",
+        "    input_signature = [tf.TensorSpec(inp.shape, inp.dtype, name=f'input_{i}') for i, inp in enumerate(model.input)]\n",
+        "else:\n",
+        "    input_signature = [tf.TensorSpec(model.input.shape, model.input.dtype, name='input')]\n",
+        "\n",
+        "onnx_model, _ = tf2onnx.convert.from_keras(model, input_signature, opset=13)\n",
+        "onnx.save(onnx_model, \"./models/model.onnx\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Input and Output shape\n",
+        "\n",
+        "Let's inspect how the model and its inputs outputs are shaped.  \n",
+        "`graph.input` displays the input shape of the converted ONNX model.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "onnx_model.graph.input"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "In this case, the shape of the input is `[? x 224 x 224 x 3]` which is similar to the original `[None, 224, 224, 3]` but its first dimension is called `unk_334` here.  \n",
+        "We can rename it defining the `dim_param` on the relevant dimension:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "onnx_model.graph.input[0].type.tensor_type.shape.dim[0].dim_param = 'batch_size'\n",
+        "onnx_model.graph.input"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "And we can do the same with the output."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(\"Before:\\n\", onnx_model.graph.output)\n",
+        "onnx_model.graph.output[0].type.tensor_type.shape.dim[0].dim_param = 'batch_size'\n",
+        "print(\"After:\\n\", onnx_model.graph.output)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Now we can save the model again, and try it out.  \n",
+        "The model works with the original settings, but this way the two will be semantically linked and more readable."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "onnx.save(onnx_model, \"./models/model_renamed.onnx\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Executing the model\n",
+        "\n",
+        "Before packaging the model, it is recommended to try it out with the `onnxruntime` Python package.  \n",
+        "To do so we need to provide  \n",
+        "- an `onnxruntime.InferenceSession` with the preloaded model  \n",
+        "- the dictionary of the `input` tensors with the expected shape and type.  \n",
+        "  To test the model we are generating a numpy array with randomized float values. \n",
+        "- the list of the `output` tensors,  \n",
+        "  now it is the last layer of our tensorflow model with name `dense`  \n",
+        "The shape can be changed by defining the variable `batch_size`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy\n",
+        "from onnxruntime import InferenceSession\n",
+        "\n",
+        "batch_size = 10\n",
+        "images = numpy.random.random((batch_size, 224, 224, 3)).astype('float32')\n",
+        "session = InferenceSession(\"./models/model.onnx\")\n",
+        "\n",
+        "if PYTHON_VERSION.minor == 11:\n",
+        "    result = session.run([\"dense\"], {\"input_0\": images})\n",
+        "else:\n",
+        "    result = session.run([\"dense\"], {\"input\": images})\n",
+        "    \n",
+        "result"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The `result` contains the output tensors in a list, in this case its the only one `dense` tensor.  \n",
+        "To get the most likely class where the images belong to, we need to extract the first element of the list: `result[0]` and to iterate through the probabilities of the classes by image searching for the highest probability.  \n",
+        "The shape of `result[0]` tensor is  `batch_size x 5` where `5` is the number of our labels."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "labels = ['Label 101', 'Label 102', 'Label 103', 'Label 104', 'Label 105']\n",
+        "for probabilities in result[0]:\n",
+        "    class_index = numpy.argmax(probabilities)\n",
+        "    print(f\"predicted class: {labels[class_index]}\\n  probabilities {probabilities}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Usage of the ONNX model\n",
+        "\n",
+        "The AI Inference Server with GPU support accepts ONNX models for execution.  \n",
+        "For this purpose the model must be packaged into a `GPURuntimeComponent` step using AI Software Development Kit.  \n",
+        "For details on how to create `GPURuntimeComponent` and build pipelines that run on a GPU enabled AI Inference Server you can study the [Object Detection](../../../e2e-tutorials/object_detection/README.md) example.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Using custom layers in your model\n",
+        "\n",
+        "AI Inference Server supports the execution of models containing custom layers.\\\n",
+        "In case of using TensorRT optimization in the model configuraton, AI Inference Server attempts to run the model on the TensorRT backend. In case of an unrecognized operation (custom layers), the given operation will be executed on ONNX runtime backend.\\\n",
+        "This could result in performance degradation."
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "keras",
+      "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.11.9"
+    }
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load the model\n",
-    "\n",
-    "For this model conversion tutorial we are going to use the same model we created and trained in our [Image Classification](../../../e2e-tutorials/image_classification/README.md) example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "import tensorflow as tf\n",
-    "import sys\n",
-    "\n",
-    "PYTHON_VERSION = sys.version_info\n",
-    "\n",
-    "if PYTHON_VERSION.minor == 11:\n",
-    "    model_path = Path('./models/classification_mobilnet-py311.h5')\n",
-    "else:\n",
-    "    model_path = Path('./models/classification_mobilnet-py310.h5')\n",
-    "\n",
-    "model = tf.keras.models.load_model(model_path)\n",
-    "model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Convert and Save\n",
-    "\n",
-    "In order to be able to convert your keras model to ONNX, you need to know the input shape and type of your model.  \n",
-    "These are stored in the properties of the original model as:\n",
-    "\n",
-    "- `model.input.shape`, and\n",
-    "- `model.input.dtype`\n",
-    "\n",
-    "Using these two, we can create an `input_signature` as `tensorflow.TensorSpec` class.  \n",
-    "In the constructor of TensorSpec you can define the `name` of the input tensor. In this tutorial, we are setting the `name` of the input tensor as `input`.  \n",
-    "Parameter `opset` defines the version of the `ONNX format`, opset version `13` refers to ONNX format `1.8.0` which is supported by AI Inference Server at the time of writing."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import tf2onnx\n",
-    "import onnx\n",
-    "import tensorflow as tf\n",
-    "    \n",
-    "if PYTHON_VERSION.minor == 11:\n",
-    "    input_signature = [tf.TensorSpec(inp.shape, inp.dtype, name=f'input_{i}') for i, inp in enumerate(model.input)]\n",
-    "else:\n",
-    "    input_signature = [tf.TensorSpec(model.input.shape, model.input.dtype, name='input')]\n",
-    "\n",
-    "onnx_model, _ = tf2onnx.convert.from_keras(model, input_signature, opset=13)\n",
-    "onnx.save(onnx_model, \"./models/model.onnx\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Input and Output shape\n",
-    "\n",
-    "Let's inspect how the model and its inputs outputs are shaped.  \n",
-    "`graph.input` displays the input shape of the converted ONNX model.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "onnx_model.graph.input"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this case, the shape of the input is `[? x 224 x 224 x 3]` which is similar to the original `[None, 224, 224, 3]` but its first dimension is called `unk_334` here.  \n",
-    "We can rename it defining the `dim_param` on the relevant dimension:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "onnx_model.graph.input[0].type.tensor_type.shape.dim[0].dim_param = 'batch_size'\n",
-    "onnx_model.graph.input"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "And we can do the same with the output."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(\"Before:\\n\", onnx_model.graph.output)\n",
-    "onnx_model.graph.output[0].type.tensor_type.shape.dim[0].dim_param = 'batch_size'\n",
-    "print(\"After:\\n\", onnx_model.graph.output)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we can save the model again, and try it out.  \n",
-    "The model works with the original settings, but this way the two will be semantically linked and more readable."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "onnx.save(onnx_model, \"./models/model_renamed.onnx\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Executing the model\n",
-    "\n",
-    "Before packaging the model, it is recommended to try it out with the `onnxruntime` Python package.  \n",
-    "To do so we need to provide  \n",
-    "- an `onnxruntime.InferenceSession` with the preloaded model  \n",
-    "- the dictionary of the `input` tensors with the expected shape and type.  \n",
-    "  To test the model we are generating a numpy array with randomized float values. \n",
-    "- the list of the `output` tensors,  \n",
-    "  now it is the last layer of our tensorflow model with name `dense`  \n",
-    "The shape can be changed by defining the variable `batch_size`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy\n",
-    "from onnxruntime import InferenceSession\n",
-    "\n",
-    "batch_size = 10\n",
-    "images = numpy.random.random((batch_size, 224, 224, 3)).astype('float32')\n",
-    "session = InferenceSession(\"./models/model.onnx\")\n",
-    "\n",
-    "if PYTHON_VERSION.minor == 11:\n",
-    "    result = session.run([\"dense\"], {\"input_0\": images})\n",
-    "else:\n",
-    "    result = session.run([\"dense\"], {\"input\": images})\n",
-    "    \n",
-    "result"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The `result` contains the output tensors in a list, in this case its the only one `dense` tensor.  \n",
-    "To get the most likely class where the images belong to, we need to extract the first element of the list: `result[0]` and to iterate through the probabilities of the classes by image searching for the highest probability.  \n",
-    "The shape of `result[0]` tensor is  `batch_size x 5` where `5` is the number of our labels."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "labels = ['Label 101', 'Label 102', 'Label 103', 'Label 104', 'Label 105']\n",
-    "for probabilities in result[0]:\n",
-    "    class_index = numpy.argmax(probabilities)\n",
-    "    print(f\"predicted class: {labels[class_index]}\\n  probabilities {probabilities}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Usage of the ONNX model\n",
-    "\n",
-    "The AI Inference Server with GPU support accepts ONNX models for execution.  \n",
-    "For this purpose the model must be packaged into a `GPURuntimeComponent` step using AI Software Development Kit.  \n",
-    "For details on how to create `GPURuntimeComponent` and build pipelines that run on a GPU enabled AI Inference Server you can study the [Object Detection](../../../e2e-tutorials/object_detection/README.md) example.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using custom layers in your model\n",
-    "\n",
-    "AI Inference Server supports the execution of models containing custom layers.\\\n",
-    "In case of using TensorRT optimization in the model configuraton, AI Inference Server attempts to run the model on the TensorRT backend. In case of an unrecognized operation (custom layers), the given operation will be executed on ONNX runtime backend.\\\n",
-    "This could result in performance degradation."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "keras",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 4
 }
diff --git a/howto-notebooks/model-conversion/pytorch-to-onnx/pytorch-to-onnx.ipynb b/howto-notebooks/model-conversion/pytorch-to-onnx/pytorch-to-onnx.ipynb
index 772a204..f35743e 100644
--- a/howto-notebooks/model-conversion/pytorch-to-onnx/pytorch-to-onnx.ipynb
+++ b/howto-notebooks/model-conversion/pytorch-to-onnx/pytorch-to-onnx.ipynb
@@ -1,266 +1,266 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
-    "SPDX-License-Identifier": "MIT"
-   },
-   "source": [
-    "# Model conversion for PyTorch models\n",
-    "\n",
-    "This tutorial explains how to convert a PyTorch Model to a standardized ONNX format, which enables you to run your model on a GPU enabled AI Inference Server.  \n",
-    "\n",
-    "In this tutorial you will learn how to \n",
-    "- load a model in 'pth' format\n",
-    "- convert and save the loaded model into 'onnx' format\n",
-    "- verify the input and output shape of the model\n",
-    "\n",
-    "For more information about the conversion and common pitfalls please refer to the official [PyTorch to ONNX exporter documentation](https://pytorch.org/docs/stable/onnx_torchscript.html)."
-   ]
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "SPDX-FileCopyrightText": "Copyright (C) Siemens AG 2021. All Rights Reserved.",
+        "SPDX-License-Identifier": "MIT"
+      },
+      "source": [
+        "# Model conversion for PyTorch models\n",
+        "\n",
+        "This tutorial explains how to convert a PyTorch Model to a standardized ONNX format, which enables you to run your model on a GPU enabled AI Inference Server.  \n",
+        "\n",
+        "In this tutorial you will learn how to \n",
+        "- load a model in 'pth' format\n",
+        "- convert and save the loaded model into 'onnx' format\n",
+        "- verify the input and output shape of the model\n",
+        "\n",
+        "For more information about the conversion and common pitfalls please refer to the official [PyTorch to ONNX exporter documentation](https://pytorch.org/docs/stable/onnx_torchscript.html)."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Configuration\n",
+        "\n",
+        "Configure model path and input size. `MODEL_PATH` is the path of the PyTorch model you want to convert to ONNX format. The converted model will be saved to `ONNX_PATH`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "MODEL_PATH = os.path.join(\"models\", \"model.pth\")\n",
+        "ONNX_PATH = os.path.join(\"output\", \"model.onnx\")\n",
+        "\n",
+        "IMAGE_WIDTH = 224\n",
+        "IMAGE_HEIGHT = 224\n",
+        "PIXEL_DEPTH = 3\n",
+        "\n",
+        "BATCH_SIZE = 1"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Check if we have a GPU available, if so, define the map location accordingly, otherwise, we will be using CPU to run our model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "\n",
+        "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "\n",
+        "if DEVICE == \"cuda\":\n",
+        "\tmap_location = lambda storage, loc: storage.cuda()\n",
+        "else:\n",
+        "\tmap_location = \"cpu\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the PyTorch model\n",
+        "\n",
+        "This model is an image classification model based on a pretrained ResNet50 model. It was retrained with the `simatic_photos` dataset. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "torch_model = torch.load(MODEL_PATH, map_location=map_location)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Move the model to the device and set it in evaluation mode"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "torch_model.to(DEVICE)\n",
+        "torch_model.eval()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Convert to ONNX\n",
+        "\n",
+        "PyTorch requires a random input for the conversion. The input size must be known beforehand.<br/>\n",
+        "Use the `input_names` and `output_names` arguments to specify the input / output variable names used in the inference pipeline.<br/>\n",
+        "Parameter `opset` defines the version of the `ONNX format`, opset version `13` refers to ONNX format `1.8.0` which is supported by AI Inference Server at the time of writing.\n",
+        "\n",
+        "> ⚠️ Warning<br/>\n",
+        "> The `verbose` parameter must be set to `False`, otherwise the ONNX exporter can get stuck in an infinite loop."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "torch_input = torch.randn(BATCH_SIZE, PIXEL_DEPTH, IMAGE_WIDTH, IMAGE_HEIGHT, requires_grad=True, device=DEVICE)\n",
+        "\n",
+        "input_names = [ \"input_1\" ] \n",
+        "output_names = [ \"output_1\" ]\n",
+        "\n",
+        "torch.onnx.export(\n",
+        "    torch_model, \n",
+        "    torch_input, \n",
+        "    ONNX_PATH, \n",
+        "    verbose=False, # Must be set to False\n",
+        "    input_names=input_names, \n",
+        "    output_names=output_names,\n",
+        "    opset_version=13)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Load the ONNX model and validate it\n",
+        "\n",
+        "Check the consistency of a model with `onnx.checker.check_model`. An exception is raised if the test fails."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import onnx\n",
+        "\n",
+        "onnx_model = onnx.load(ONNX_PATH)\n",
+        "onnx.checker.check_model(onnx_model)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Input and Output shape\n",
+        "\n",
+        "Let's inspect how the model and its inputs and outputs are shaped.\n",
+        "`graph.input` displays the input shape of the converted ONNX model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "onnx_model.graph.input"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "In this case, the shape of the input is `[1 x 3 x 224 x 224]`.<br/>\n",
+        "The shape of the output is `[1 x 5]`, which can be displayed with the following:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "onnx_model.graph.output"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Executing the model\n",
+        "\n",
+        "Before packaging the model, it is recommended to try it out with the `onnxruntime` Python package.  \n",
+        "To do so we need to provide  \n",
+        "- an `onnxruntime.InferenceSession` with the preloaded model  \n",
+        "- the dictionary of the `input` arrays with the expected shape and type.  \n",
+        "  To test the model we are generating a numpy array with randomized float values. \n",
+        "- the list of the `output` arrays.\n",
+        "\n",
+        "\n",
+        "The `result` variable contains the output tensors in a list."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy\n",
+        "from onnxruntime import InferenceSession\n",
+        "\n",
+        "images = numpy.random.random((BATCH_SIZE, PIXEL_DEPTH, IMAGE_WIDTH, IMAGE_HEIGHT)).astype('float32')\n",
+        "session = InferenceSession(ONNX_PATH)\n",
+        "\n",
+        "result = session.run([\"output_1\"], {\"input_1\": images})\n",
+        "result"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Usage of the ONNX model\n",
+        "\n",
+        "The AI Inference Server with GPU support accepts ONNX models for execution.  \n",
+        "For this purpose the model must be packaged into a `GPURuntimeComponent` step using AI Software Development Kit.  \n",
+        "For details on how to create `GPURuntimeComponent` and build pipelines that run on a GPU enabled AI Inference Server you can study the [Object Detection](../../../e2e-tutorials/object_detection/README.md) example."
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "image_classification",
+      "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.11.9"
+    }
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Configuration\n",
-    "\n",
-    "Configure model path and input size. `MODEL_PATH` is the path of the PyTorch model you want to convert to ONNX format. The converted model will be saved to `ONNX_PATH`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "MODEL_PATH = os.path.join(\"models\", \"model.pth\")\n",
-    "ONNX_PATH = os.path.join(\"output\", \"model.onnx\")\n",
-    "\n",
-    "IMAGE_WIDTH = 224\n",
-    "IMAGE_HEIGHT = 224\n",
-    "PIXEL_DEPTH = 3\n",
-    "\n",
-    "BATCH_SIZE = 1"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Check if we have a GPU available, if so, define the map location accordingly, otherwise, we will be using CPU to run our model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "\n",
-    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
-    "\n",
-    "if DEVICE == \"cuda\":\n",
-    "\tmap_location = lambda storage, loc: storage.cuda()\n",
-    "else:\n",
-    "\tmap_location = \"cpu\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load the PyTorch model\n",
-    "\n",
-    "This model is an image classification model based on a pretrained ResNet50 model. It was retrained with the `simatic_photos` dataset. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "torch_model = torch.load(MODEL_PATH, map_location=map_location)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Move the model to the device and set it in evaluation mode"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "torch_model.to(DEVICE)\n",
-    "torch_model.eval()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Convert to ONNX\n",
-    "\n",
-    "PyTorch requires a random input for the conversion. The input size must be known beforehand.<br/>\n",
-    "Use the `input_names` and `output_names` arguments to specify the input / output variable names used in the inference pipeline.<br/>\n",
-    "Parameter `opset` defines the version of the `ONNX format`, opset version `13` refers to ONNX format `1.8.0` which is supported by AI Inference Server at the time of writing.\n",
-    "\n",
-    "> ⚠️ Warning<br/>\n",
-    "> The `verbose` parameter must be set to `False`, otherwise the ONNX exporter can get stuck in an infinite loop."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "torch_input = torch.randn(BATCH_SIZE, PIXEL_DEPTH, IMAGE_WIDTH, IMAGE_HEIGHT, requires_grad=True, device=DEVICE)\n",
-    "\n",
-    "input_names = [ \"input_1\" ] \n",
-    "output_names = [ \"output_1\" ]\n",
-    "\n",
-    "torch.onnx.export(\n",
-    "    torch_model, \n",
-    "    torch_input, \n",
-    "    ONNX_PATH, \n",
-    "    verbose=False, # Must be set to False\n",
-    "    input_names=input_names, \n",
-    "    output_names=output_names,\n",
-    "    opset_version=13)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load the ONNX model and validate it\n",
-    "\n",
-    "Check the consistency of a model with `onnx.checker.check_model`. An exception is raised if the test fails."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import onnx\n",
-    "\n",
-    "onnx_model = onnx.load(ONNX_PATH)\n",
-    "onnx.checker.check_model(onnx_model)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Input and Output shape\n",
-    "\n",
-    "Let's inspect how the model and its inputs and outputs are shaped.\n",
-    "`graph.input` displays the input shape of the converted ONNX model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "onnx_model.graph.input"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this case, the shape of the input is `[1 x 3 x 224 x 224]`.<br/>\n",
-    "The shape of the output is `[1 x 5]`, which can be displayed with the following:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "onnx_model.graph.output"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Executing the model\n",
-    "\n",
-    "Before packaging the model, it is recommended to try it out with the `onnxruntime` Python package.  \n",
-    "To do so we need to provide  \n",
-    "- an `onnxruntime.InferenceSession` with the preloaded model  \n",
-    "- the dictionary of the `input` arrays with the expected shape and type.  \n",
-    "  To test the model we are generating a numpy array with randomized float values. \n",
-    "- the list of the `output` arrays.\n",
-    "\n",
-    "\n",
-    "The `result` variable contains the output tensors in a list."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy\n",
-    "from onnxruntime import InferenceSession\n",
-    "\n",
-    "images = numpy.random.random((BATCH_SIZE, PIXEL_DEPTH, IMAGE_WIDTH, IMAGE_HEIGHT)).astype('float32')\n",
-    "session = InferenceSession(ONNX_PATH)\n",
-    "\n",
-    "result = session.run([\"output_1\"], {\"input_1\": images})\n",
-    "result"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Usage of the ONNX model\n",
-    "\n",
-    "The AI Inference Server with GPU support accepts ONNX models for execution.  \n",
-    "For this purpose the model must be packaged into a `GPURuntimeComponent` step using AI Software Development Kit.  \n",
-    "For details on how to create `GPURuntimeComponent` and build pipelines that run on a GPU enabled AI Inference Server you can study the [Object Detection](../../../e2e-tutorials/object_detection/README.md) example."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "image_classification",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 4
 }