Fahrzeugerkennung.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled25.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPYC0coK6b35okTJRc3r5vp",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PaSeitz/BA-Fahrzeugerkennung/blob/main/Fahrzeugerkennung.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vt82lyA7VKBO"
      },
      "source": [
        "# **Fahrzeug**erkennung"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "462lWl5bVZ9W"
      },
      "source": [
        "# **Bounding Box Detection** Modul"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YOOafBwXVQ1C"
      },
      "source": [
        "import tensorflow as tf\r\n",
        "import tensorflow_hub as hub\r\n",
        "tf.get_logger().setLevel('ERROR')\r\n",
        "!git clone --depth 1 https://github.com/tensorflow/models"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "18OYt-hlV5X5"
      },
      "source": [
        "Object Detection **API** installieren."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KYhcZlMcViK7"
      },
      "source": [
        "%%bash\r\n",
        "sudo apt install -y protobuf-compiler\r\n",
        "cd models/research/\r\n",
        "protoc object_detection/protos/*.proto --python_out=.\r\n",
        "cp object_detection/packages/tf2/setup.py .\r\n",
        "python -m pip install ."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9c54l0enV-QL"
      },
      "source": [
        "**GPU** verwenden. Sollte ein Fehler auftreten, dann muss die **GPU** manuell als Hardwarebeschleuniger ausgewählt werden. \r\n",
        "* *Laufzeit -> Laufzeittyp ändern -> **GPU** -> Speichern*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4GUd6sXeVi7c"
      },
      "source": [
        "device_name = tf.test.gpu_device_name()\r\n",
        "if device_name != '/device:GPU:0':\r\n",
        "  raise SystemError('GPU device not found')\r\n",
        "print('Found GPU at: {}'.format(device_name))\r\n",
        "tf.device('/device:GPU:0')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OFXUktewXR-X"
      },
      "source": [
        "**EfficientNet**-D5 von TensorFlow Hub herunterladen. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sn6tRgNzVx7s"
      },
      "source": [
        "from object_detection.utils import label_map_util\r\n",
        "model = hub.load('https://tfhub.dev/tensorflow/efficientdet/d5/1')\r\n",
        "PATH_TO_LABELS = './models/research/object_detection/data/mscoco_label_map.pbtxt'\r\n",
        "category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bm22-wRFXMzR"
      },
      "source": [
        "Auswahlmöglichkeit verschiedener **Kategorien**.\r\n",
        "\r\n",
        "![Unbenannt.JPG](data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/4RDgRXhpZgAATU0AKgAAAAgABAE7AAIAAAAHAAAISodpAAQAAAABAAAIUpydAAEAAAAOAAAQyuocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBhdHJpawAAAAWQAwACAAAAFAAAEKCQBAACAAAAFAAAELSSkQACAAAAAzU5AACSkgACAAAAAzU5AADqHAAHAAAIDAAACJQAAAAAHOoAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMDIwOjEyOjE3IDA4OjQ3OjE2ADIwMjA6MTI6MTcgMDg6NDc6MTYAAABQAGEAdAByAGkAawAAAP/hCxlodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0n77u/JyBpZD0nVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkJz8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIj48cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPjxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSJ1dWlkOmZhZjViZGQ1LWJhM2QtMTFkYS1hZDMxLWQzM2Q3NTE4MmYxYiIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIi8+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iPjx4bXA6Q3JlYXRlRGF0ZT4yMDIwLTEyLTE3VDA4OjQ3OjE2LjU4NzwveG1wOkNyZWF0ZURhdGU+PC9yZGY6RGVzY3JpcHRpb24+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iPjxkYzpjcmVhdG9yPjxyZGY6U2VxIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpsaT5QYXRyaWs8L3JkZjpsaT48L3JkZjpTZXE+DQoJCQk8L2RjOmNyZWF0b3I+PC9yZGY6RGVzY3JpcHRpb24+PC9yZGY6UkRGPjwveDp4bXBtZXRhPg0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSd3Jz8+/9sAQwAHBQUGBQQHBgUGCAcHCAoRCwoJCQoVDxAMERgVGhkYFRgXGx4nIRsdJR0XGCIuIiUoKSssKxogLzMvKjInKisq/9sAQwEHCAgKCQoUCwsUKhwYHCoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq/8AAEQgBIQDCAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A91ooqpf38djDub5nP3U9f/rUAWJH2RuwxlVJxT6wNPuZJ7bUppmy3l5+nDVv0AFFFFABRRXM+OtSjs9AS0f7QW1KdLTFtBJNJsPMpCRgscRq/QelIDpqK5nwLqUV5oktlGJ1OmTtaqtzbyQSCIcxEpIqsP3ZUZI5INdNVAFFFFIBkr7Inf8AuqTT6gvTtsLg+kTH9KnoAKKKKACiiuL+I1p9vXw7bf2dZan5mrgfZL9tsMn+jzHDHY/1+6eQPrQPv8ztKK5vwE0Z8IwxQqUEE9xA0YxsjZJnUpHj/lmpG1enygcDoOkpvQQUUUUgGSvsid/7qk0+oL07bC4PpEx/Sp6ACiiigCIzoOok/CNj/Ssu5sbS4maWaS9Zj6RNx7fdrZrM0vXbfVr6+toILqJrJlVmuITFvyDyob5sZBGSBnGRkEEgFWRbSw0u9EAuyZIW+/A+BhT32jHWr/8Aa1r6XH/gLJ/8TT9V/wCQNe/9e8n/AKCaw9R8SWGk3csF80kflWv2pn25BXfsCgDksWIAAHOQBzXmY/GTwzioRve/4WOmhRVS93a1vxNn+1rX0uP/AAFk/wDiaP7WtfS4/wDAWT/4msh/EOm2sFk2rXUOkzXoBhtr+eOOUscfLjcQWGQCAT1qK08V6NfeJLvQre+ga/tFUvEJkJbOcgAHJK4+bjjIrzP7Yr6v2Zv9Vh/Mbn9rWvpcf+Asn/xNRvfadJPFPJDI8sOfLkazkLJng4O3jNULDXdI1Vp10vVbK9Nv/rhbXCSeV1+9tJx0PX0NRWXijQNT87+zdc0278iMyy+RdxyeWg6s2DwPc0v7Zr/8+9vUf1SH8xqJfadHcSTxwSLNKFEki2cgZwM4yduTjJx9ak/ta19Lj/wFk/8Aiay7bxDot7YPfWer2FxaRyCN7iK5Ro1ckAKWBwCdw49x602y1/T9Su4otNuYbyKWBpkuLe4ikQhW2kDDbjz3AxxjOeKf9s1utP8AMPqkLfEa39rWvpcf+Asn/wATR/a1r6XH/gLJ/wDE1m6drmk6vJMmk6pZXzwECZba4SQxk5xu2k46Hr6Gr1S86qp2cF+I/qcX1GX2pwS6fcRxLcM7xMqj7NIMkg4/hqf+1rX0uP8AwFk/+JqOs+bW7S31s6ZOWjkWza8aV8CNY1YKckng856Yx3oWd1XtBA8HFdTU/ta19Lj/AMBZP/iaP7WtfS4/8BZP/iazrLW9K1KeeHTtTs7uW2/18cFwrtF/vAHjoevpVCy8W6bqmvw6dpF1aahG9vLM9xa3KyLGyNGNhC55PmZ69unNUs4rt29mS8LBK/MdB/a1r6XH/gLJ/wDE1T1MaHrVqLbWdOTUIFYOIrrT2lUMMjOGQjPJ596q23iTQ72K6ks9Z0+4js13XLRXSMIBzy5B+UcHr6GrqXdtJcNbx3ETzKiyGNXBYI2QGx1wcHB9jSec1lvT/Mr6pH+Yltr3TbK1jtrOCS3giUJHFFZyKqKOgAC4A9qk/ta19Lj/AMBZP/iajoqf7cqfyIPqce5J/a1r6XH/AICyf/E0f2ta+lx/4Cyf/E1HRR/blT+RB9Tj3GX2pwS6fcRxLcM7xMqj7NIMkg4/hq79rH/Pve/+AUv/AMTVWuur1Mvx0sXzcyta343OavRVK1nuc39rH/Pve/8AgFL/APE0V0lFeqcxh1k2FlcQeJtXu5Y9sFysAibcDu2qwbjqOo61omJz0nkH0C/4U028h6Xcw+gT/wCJoAj1X/kDXv8A17yf+gmuG8TeFr7V/FUGqWBEU1haB7SWR8xGdZM7HTPIK5GcfLnI5FdhqltKNJu2N9OwEDkqVjwflPH3c1v/ANiW39+X8x/hXk5hh69aUJUd1f8AGx1UKkIxlGfWx474x0/xVr1ndx2em3Vst9pixiG3ks+Jvn3RzvJlioyNpi7lskZyNTUNH1W51LxDawW8kcer6XHBDfrKmyGVUkUhhu39WHKqRXp39iW39+X8x/hR/Ylt/fl/Mf4V5f8AZ+M5eVRj/Vv8jp+sUubmuzxG+0i6t/Dmp3GrLrds1ros9lE98bH7OquFXaotgJG5VcbgB9CaeljqmpwaraahbS/23IlncizlhhgiubeCXPlgJNMAWO5SWYfeHGAa9ol8P2U8LxT75I5FKuj4IYHggjHIqppngrQtFjePRrCDT0kO51tYUiDH1IVRmtVgsXbWKv8A8G/579/Ij2tLRJ/1t+X3Hl+u6BqfiSPVrs6K1p9sjsrf7HcyQmSZYrjzHd9rsmArEAbiTg8dK1PEHh7UNU129ayxBFcaDNYx3O8AJKzgrwPm6c5Ar0r+xLb+/L+Y/wAKP7Etv78v5j/Csv7PxmlktL9e6S/Qv6xS7vp+Dv8AoeXeFtGvYdZtrnUoddjeys2tojetYeQFJTKr9nAc/cGNwAwOxNdpW7/Ylt/fl/Mf4Uf2Jbf35fzH+FZ1MrxdR3aX3hHEUoKyuYVcp4g0XUL7Xr64tbffFLoE9mjb1GZmYFVwT3Hfp716JPpEEVtLIryEohYZI7D6VJ/Ylt/fl/Mf4VMMqxcHdJfeW8VSf4fg7nlWp+E764torXTIY7Nf+EduNPDoVRY5W8vYuBzjhuQCBz61BcaLrGvXksi6KdB3aDPpqSyzxFxIxQqP3Rb5BhsHOfvfKvG71z+xLb+/L+Y/wo/sS2/vy/mP8K3+oY3suvXvf/MzVaitm+n4W/yR5Nouk6ja3H2y807Xrmex06S3t7e7k05YZAdv7pTDtPJQYLgADPQ8Ve8CeHr/AMMx3ljfwxyK4ilju45C2fkCmD5iW2x7cKem0jvuz6X/AGJbf35fzH+FH9iW39+X8x/hSll+MkmrLXz+YKtRVtXp/wAMYVFbv9iW39+X8x/hR/Ylt/fl/Mf4Vz/2Piuy+80+tUzCord/sS2/vy/mP8KP7Etv78v5j/Cj+x8V2X3h9apmFXXVlT6RBFbSyK8hKIWGSOw+lX/Ik/5+pfyT/wCJr2crwdXC8/tOtv1OTE1Y1LcpNRUPkSf8/Uv5J/8AE0V7JyGRXLeHrUx+IribS7vUbnTBAY55r26kmSe43DBiDk4AG4MUCoSwAztIXpJJI2jZHWQqwIOI26fgKxtJ0PSdBkVtPOr4SPyljnvLy4jVeMAJIzKMY4wOKFvf+v6/roD2samq/wDIGvf+veT/ANBNM1fVfEUvi2TRfDz6XbrHp6XjXF9BJMdxd12bEdODtHzZ4weGzxDql9E2k3ahJ8tA4GbeQD7p77cCk1bwlZa74wfVNTS4Nt/Z6WqG2luLeYHe7MN0e07CGGRuwSORwKl3uref5P8AWw9LP5fmv0MF/iZqepx6cukW/wBhkn0mHUJmbRrvU13SlgsQFvtKDKN87deMKea1tP8AFPiTW/E1nY2tnaaXAdIttSu4b63ke4Vnd1aADcgU/J95h8pHKnPy7F94a0K/+zFra8tGtYRBE+nzXNmyxDpHmEqSo7Kcgdqt2+maZbX5vYobr7U1olm07mZ3aJCxUEnJJyzHd9455NX1+/8AW36fd96/4H6X/X7zkLbx1rMWjXb6n9kXWfNtoI9Kk0+a2NpJPN5Ss8jOwnjDH/WRgK204PPE+qeLPEegR6tZXg0vUNQtYbS4tp4oZLeKRZpzEUdC8hUgqTuDHOfu/Kc7EfhHw6tne201pfXiX0Qhna+uLq5coCSFV5WZkAJJG0jB5681JB4Y0CCxuLX7LeTrcvG80l1NczyyGNgyAyuS5CkZC5wOeOTlf1/X+fyD+v6/rzE8O6prEmvaro2vyWM89lHBPHPZQPCrJKHG0qzucgxnnPII4FdHWfFb2MOqXGoxQSrdXUccUsnlyHcqbtoxjAxvbp61a+1R/wB2X/vy/wDhQBNRUP2qP+7L/wB+X/wo+1R/3Zf+/L/4UAF5/wAeM/8A1zb+VTVUurlGs5gFlyY2HMTDt9Kl+1R/3Zf+/L/4UATUVD9qj/uy/wDfl/8ACj7VH/dl/wC/L/4UATUVD9qj/uy/9+X/AMKPtUf92X/vy/8AhQBNRUP2qP8Auy/9+X/wo+1R/wB2X/vy/wDhQBNUdxE81tLFHPJbu6FVmjCloyR94bgRkdeQR6g037VH/dl/78v/AIVHcPDc20sEguVSVCjGNZI2AIxwy4Kn3BBHahjW5y/gp7g+H9fhury6vDb6peQpJdTGR9qngZPb2GAOwFdlXNaX4b0bw5b3zaQmpIbpXaUXN5dXCs55LYlZgGJ6t1Pc1v8A2qP+7L/35f8Awo6JeS/IXV+rJqKh+1R/3Zf+/L/4UUAZNY2meIhqGpvYXGl3+m3Hk+fEt4sf76PdtLKUdsYJGQ21uRxWwchTtGTjgZrkvD1lqH/CTy37aZqGmWsluyzx6leJcvJKXBXymEkhRFG/5dyr8wwnU0LcHsdHqv8AyBr3/r3k/wDQTWxqOvaPo9xbQatqtjYzXTbbeO5uUjaY5AwoYjcckdPUVj6r/wAga9/695P/AEE1T1PT9Ss/HN9qMWgf25aappsNkMSxKLco8hZZBIw/dsJASUDH5T8p4ydUg6M6OPX9Hl1qTSItVsX1OJd0lktyhmRcA5KZ3AYI7dxS6br2kaxJLHpGq2V+8ARpVtbhJTGGGVLBScZHIz1rgbXQ/Flx440q51C1uY7Sx1O7mcRtZpZrE8cyo0QUeeWO5C+8/eYnBHI6j4eaLP4d+Huj6Xe2qWl1b24E8SFSBISSxyuQSSSSe5NC2uD3sdLRRRQAUUUUAFFFFAEN5/x4z/8AXNv5VNUN5/x4z/8AXNv5VNQAUUUUAFFFFABRRRQAVFdTi1tJrho5JREhcpEhd2wM4VRyT6Cpar37zx6dcPaW5uZ1iYxwCXyzI2OFDfw56Z7UnsNbmRp3iRNaj1Szl0680y+sYx51reeWXCupKODG7qQcMPvZypyBxW/XC+E9IvtPvPEF0+mXul6ddQx+XBqd2l1dSTKrB5GlEkhK7fLUBpDjacBR17qqZKCiiikM54xOek8g+gX/AAppt5D0u5h9An/xNPuJ4rW2kuLiRY4YkLyOxwFUDJJ/CuC8JeL7bxF46uZYddtp4rqwR7bTobtH8lVduSqk/vCDubuAVHbJFrK39f1oD0VzrdUtpRpN2xvp2AgclSseD8p4+7muq8iT/n6l/JP/AImue1X/AJA17/17yf8AoJqrdS67/wALbt4INUt00z+y3ma0a2dicSIDyJQu/J4bbwMjBzmlfW3r+Cb/AEB6Jv8Arex1fkSf8/Uv5J/8TR5En/P1L+Sf/E1wnh7xd4jvvD/hzV9V/svZrt1FEtvbW8gMKFJGJLtIdxJRSBtAXJHzfeqxeeMNXk1WXSNNSxiu5tcOm289xGzxxRrai4Z2QOpdvvAAMvUHsc1bVrt/wP8ANA9N/wCt/wDJnZ+RJ/z9S/kn/wATR5En/P1L+Sf/ABNea6pr2r6J8RLe0nSzk1jUtOgtEuhFItnExnlxI/JK5AGI92WYhQ38Q9PXIUbiC2OSBgE0lrHm9fwYPSVvT8UReRJ/z9S/kn/xNHkSf8/Uv5J/8TU1FAEPkSf8/Uv5J/8AE0eRJ/z9S/kn/wATU1FAFS6hcWcxNzKQI24IXnj6VL5En/P1L+Sf/E0Xn/HjP/1zb+VTUAQ+RJ/z9S/kn/xNHkSf8/Uv5J/8TU1FAEPkSf8AP1L+Sf8AxNHkSf8AP1L+Sf8AxNTUUAQ+RJ/z9S/kn/xNHkSf8/Uv5J/8TU1FAEPkSf8AP1L+Sf8AxNHkSf8AP1L+Sf8AxNTVk+KrprHwjq1zHfppzxWcrJduhYQNtOG2gEnBxwASfQ9KTdlcaV3Yt3ULizmJuZSBG3BC88fSpfIk/wCfqX8k/wDia8/8FTXcd/rFlfjUrBxp8Mq6ZqV/LevnDh50lcn5GPy7QQRsyyoWxXo1U1YlO5D5En/P1L+Sf/E0VNRSGc8Z0HUSfhGx/pVXbZrqJvvJm+0mIQlxFIfkBJAxjHUmr9Y+ia++tlnj0i+tbXBMV1cNAUmw2PlCSM3v8yjijqHQk1S+ibSbtQk+WgcDNvIB9099uBWxeaVpd9rNpqs8N2L2zRkiliaeL5WIJVgpAdcqDhgRxVDVf+QNe/8AXvJ/6Can1Lxlpei+IpNO1u7s9Nt1tY51vLu6WJGZ3dRH82BnCE9fw4paXS/rb/IOjB/Dmgv4bttBFlcJp9psNukbTo8JQ5VlkUh1IPcNmq6+DPDEelPp8enXMcL3QvC6SXCyicAL5olB3q5A5YMCctnO452/7Vg/thdPGC7WxufMEseNm4L93dv7/e27ffPFQad4o0DWGVdJ1zTb5ndkUW13HIWYDcVG0nJA5I9Kf9f180F/6/r1KDeFfDklnNbS6dLLFPbfZZfM852dN5fJYnJfexbfnduOc5rbjmiiiSNROVRQoLRyMcD1JGSfc1UvfE2g6Zatc6jrenWlusxt2lnu440Eo6x5JxuGDx1qvZeJoLrW9aspFjht9Kigma7aYbHSRGfceMKAF65P4UX0/r1Dqav2qP8Auy/9+X/wo+1R/wB2X/vy/wDhVfStb0rXbVrnQ9Ts9SgR9jS2dwsyq2AdpKkjOCOPer1AEP2qP+7L/wB+X/wo+1R/3Zf+/L/4VNRQBUurlGs5gFlyY2HMTDt9Kl+1R/3Zf+/L/wCFF5/x4z/9c2/lU1AEP2qP+7L/AN+X/wAKPtUf92X/AL8v/hU1FAEP2qP+7L/35f8Awo+1R/3Zf+/L/wCFTUUAQ/ao/wC7L/35f/Cj7VH/AHZf+/L/AOFTUUAQ/ao/7sv/AH5f/Cq9/FY6pp1xYahbvcWtzG0U0TwPh1IwQeKvVDd3AtLOa4aOWURIXKQxl3bAzhVHJPtSew1e+hh2OgaPocd7Pp8N61zcQ+W9xeT3FzIVUHau+UsQoJJwCByTW59qj/uy/wDfl/8ACsPT/E6axJqenT6ZfaVf2dusslte+UWMbhtrq0TupGUYdcgjkdK6KqJIftUf92X/AL8v/hRU1FIZhHpxXHeG9IaPxJ/aVt4XHhiI2rJdxKYB9slZlKtiFmDBcP8AM2G+fp1rrTE56TyD6Bf8KabeQ9LuYfQJ/wDE0LR3DpYj1X/kDXv/AF7yf+gmqOuWep2nj19atfDLa3bvpIsgYpoFkRzI7FcSso2Ebdxz/d4bnEuqW0o0m7Y307AQOSpWPB+U8fdzXVeRJ/z9S/kn/wATSaT/AK7q36jvpb+t7nmbfD7Wxo66SjREjwg2kfafMxH55YYTjDbcDGcdPfirHime8h8HN4lbwv8A2PqHh4wXNtFPPCXn2bleEGJmGwpI6Lk5y5+UcZ9E8iT/AJ+pfyT/AOJqG602K+gMF632iIsrGOWON1ypDKcFeoIBHoQKbbf9ebf6i66/1ol+hw9p4c1Tw5c+G9Ti0mTWZLWxuYr6G2kiSVbm4ZJHmXzXRSCyup+bOGGMjNV9W8GazqNv4ljtrRNPW8TTWt4beWPawg5khTK7R02jem05GRjNejeRJ/z9S/kn/wATR5En/P1L+Sf/ABND1/rzuC7nLeDdKu4dW1LVNUj8QLd3MUULNrDWHzqhcjaLTjI3nJbnkY6V19Q+RJ/z9S/kn/xNHkSf8/Uv5J/8TTAmoqHyJP8An6l/JP8A4mjyJP8An6l/JP8A4mkAXn/HjP8A9c2/lU1VLqFxZzE3MpAjbgheePpUvkSf8/Uv5J/8TQBNRUPkSf8AP1L+Sf8AxNHkSf8AP1L+Sf8AxNAE1FQ+RJ/z9S/kn/xNHkSf8/Uv5J/8TQBNRUPkSf8AP1L+Sf8AxNHkSf8AP1L+Sf8AxNAE1VtRnuLXTLmexs2vrmOJmitVkVDMwHC7m4GTxk9Kf5En/P1L+Sf/ABNHkSf8/Uv5J/8AE0PYDjvCcWqlNVvvEeh39lq19Dvubmd7YwgKCEgiEUzttXcxywGSWJwTgdvVS6hcWcxNzKQI24IXnj6VL5En/P1L+Sf/ABNAiaiofIk/5+pfyT/4migZizSeVBJJgtsUtgd8CuH8G6hey31hea1bXKz65aNcQS/2pLMmAFYq1vgRw8MNuzccA7myct25nQdRJ+EbH+lY+naJouj3r3dja3SSspRdxnkWFSclY1bKxqSB8qADgccChaO4PY0tV/5A17/17yf+gmsvx/43vPDDTnTZ7Z2srX7VPanTbm7eRcnhniwtuCFOHfcCc8AKc29Uvom0m7UJPloHAzbyAfdPfbgVb1vwn4d8RXMs+rWN1K88At5xHJcRLPGM4WRUIV8FmI3A4J4xR1Q1bqYGu+LtS0i88Uz6bBBLPZvpkcCXM0pjbz3CHI3EL97qij1O7FaE2o+MTr39hWt5of2mLT1vJbySxm2MxkdQixCbIBCr8xc4weDuwutdeH9CvWvGubGVzfNA9wcTDeYGDRdOm0gdMZ75rM1bwlZa74wfVNTS4Nt/Z6WqG2luLeYHe7MN0e07CGGRuwSORwKWt7ev5afiKPw67/8ABX6GHp3ihL/xJZ+Jp1gsxL4QN263EpWOI+apIZ8Z2g98dO1EXxD1tbDXVCW15d6eLKS3km0u601JBPKYyrRzEvxtPzjI56cEV2E/h7w/c7hNpe5GsDpxjEMgT7MTnywoGAOB2yKq23g/w3bR3SrZ3kpvBCLiS4nuZpJBE5ePLuxb5SeOenHTinpa3r+Mm/yYvP0/JL9GY2oeNdb8OWmuwawllf31iLM2r2NpKiMblzGoaPe7ttZSflOWGAADWr4O8Rarq99f2mqQSSJbpHJDff2Pdackm7cDH5dwSSy7QdwYghxwCOdK70fRr6S+e7sXla/ijhuC0cnzqhYpj+6QWJBGDnBzwKXSNMsNEWUWcmqyeaQW+23d1dYx6eazbevbGaa63G9jYoqH7VH/AHZf+/L/AOFH2qP+7L/35f8AwpAF5/x4z/8AXNv5VNVS6uUazmAWXJjYcxMO30qX7VH/AHZf+/L/AOFAE1FQ/ao/7sv/AH5f/Cj7VH/dl/78v/hQBNRUP2qP+7L/AN+X/wAKPtUf92X/AL8v/hQBNRUP2qP+7L/35f8Awo+1R/3Zf+/L/wCFAE1UtZtrq80K/tdPm8i7mtpI4Jd5Xy3KkK2RyMHByOan+1R/3Zf+/L/4VW1CGz1XT5rK9ineCYYYIsqMOcghlwykEAggggjIpSV00NOzucp4SefTpdW8P6pb3EWpW9nFcvI2s3GpRSo4dQytNgxncjZUKB0OT27qsCx0bStDs77+zobrzrpczT3Uk9xLJhcKGllLMQOwJwMnHU1s/ao/7sv/AH5f/CqbvqSlYmoqH7VH/dl/78v/AIUUhmQxIUkAsQOg6msHT/FE15ryaVdeHtU0+Z4Gn8y4a2ZFUEDkxTOQSTgZHOD6Gt+sfRbG4j1HVtRv4jHPd3OyNWYNtgjG2MDBPBO58dfnOaFuHQu6r/yBr3/r3k/9BNa2qeIdF0QZ1rV7DTx8v/H3cpF97O37xHXa2PXafSsnVf8AkDXv/XvJ/wCgmotV8PT3vi3U782UcsU2gmxilbYSXLuWTnkAgpnsePSpk2vx/Jv8dikk9/61X/Dm9Z63pWo3lzaafqdndXNmQtzDBcK7wH0dQcr0PX0qifGvhltNv7631/TLmDTk3XTQXkb+T1wGIbCkkEDOMmuOufAurXGnaZYWcKaeq+EbjS5ZFdQsNw/k7VIU5Iyr8gEdfUZ0INK1TW9StbuXw83h9bHR7iwEc80LGVpRHhE8pmHlr5Z5baeRhetVNWTt5/hf87L7/vmGtr+X6f5v7jftPG/hu68M22vnWrC3024CgTz3caqjkZ8tm3bQ46Fc9QatXfibQbCygvL7W9OtrW4j82Gea7jRJU+X5lYnBHzryOPmHqK46wsddso/CeqzeGryeXSdPk0+404T23nRuyRgTxkybCP3bL98Nh+nUUuh+D9QtfEvh7ULvToY4bZtUuXjDIwsmuZUeNB6ttLglcjO7nBGaaXNZbf1+f8AwNxRvyq+/wDX/DfidfL4q8PW+oTWM+u6ZFd26B5rd7yMSRrxyyk5A+Ycn1HrVu51TT7NplvL62gaCE3EolmVTHEODI2TwvB5PHFcVpXhu5fTtR8La74d86zubu9mfVTNEY5EnaQhlG4yiXbJsOVAADYbGAcDRtI1vxT4EvNZvLaG81R721RYfMAW7gsZlBUMcD946TOM/Ll1ycc1K1t8v6+XYb0/r+t/wO9HjHT7nVtEttHmttTtdWedFvLW5V0QxJuOCuQ3p1GK0LXxDot9q0+l2Wr2FxqFuCZrSG5R5YsEA7kByMEgcjvXOS6fqer+KdC1YaG+lRwzXTXIllhMo3W4jR38tiCSRgbWb5QuSOgw/CHhHVtOvNCstbXxDINFZ2jn36d9iLlHVmBQC5KtvJwwzkjdnGaF8VhdLnpV5/x4z/8AXNv5VNUN5/x4z/8AXNv5VNQMKKKKACiiigAooooAKKKy/Eml3eteHbzTtPvxp89ygT7QYjJtXI3DAZTyuRkMCM5ByKT20GrX1M/R/GGn+KYtZi0yO4C6eTE0sqBUmBUkPHgklTjgkDPXpzXSVwnhjw94g0bW/Es+rS6c1jcQwrb/AGOyMAfZCFG1TM+xVA27SOTyCBxXd0yVfqFFFFAznjE56TyD6Bf8KabeQ9LuYfQJ/wDE1JLIsULySMERFLMx6ADvXB+C575dXszezaiv26xeWRr2d5I76QMhEsCMT5KgM3yERkhl+U7cgWrsHS51eqW0o0m7Y307AQOSpWPB+U8fdzXVeRJ/z9S/kn/xNc9qv/IGvf8Ar3k/9BNZmqrrj/FC4Xw7Pp9vL/YsTPLfQvMvE0uFCIydT/Fu4x9054Tdmk/P8E3+g7aN/wBbpfqdp5En/P1L+Sf/ABNHkSf8/Uv5J/8AE1yfh7xrda75Mv2WKCKbQotTCfMWWR2cFc8ZUbRjgGqMPjPWpf8AhH7i8a00vT9RsbWeS8k06a4ilmkI3Rb1kUW+MqFaTIYvgZIINW1t8vzX6MT03/rb/NHdeRJ/z9S/kn/xNHkSf8/Uv5J/8TU1FICHyJP+fqX8k/8AiahtdNisbSO1sW+zW8S7Y4YY40RB6ABcAVcooAh8iT/n6l/JP/iaPIk/5+pfyT/4mpqKAKl1C4s5ibmUgRtwQvPH0qXyJP8An6l/JP8A4mi8/wCPGf8A65t/KpqAIfIk/wCfqX8k/wDiaPIk/wCfqX8k/wDiamooAh8iT/n6l/JP/iaPIk/5+pfyT/4mpqKAIfIk/wCfqX8k/wDiaPIk/wCfqX8k/wDiamooAh8iT/n6l/JP/iaPIk/5+pfyT/4mpqxfGWrz6D4I1rVrNQ1xZWUs0QIyNyoSMjuM0m7K44q7sX7qFxZzE3MpAjbgheePpUvkSf8AP1L+Sf8AxNcN4VlubHUNS0jV4LldQfTkvPtDa3PfxzoSykhZFVYm3DJVFC4IwcDA7+qsSnch8iT/AJ+pfyT/AOJoqaikM55pkwQyuQeCPLY/0rF03QtE0a7+02NteCRUMcYke4mWBCQSkSuSsa8DhABgAdhW6zBFLOQqqMknsKxNH8UwaxdxwixvbNbiE3FnLcogW7iBGXTaxI+8pw4VsMOOuBb6B0LOqX0TaTdqEny0DgZt5APunvtwKvaz4Y0DXr8X2o2t59rEPkCe3mubeTysklN0ZU7SWOR0PGc4GItV/wCQNe/9e8n/AKCatTeM9CtvGEfhmfUbePU5YfNWJp0BPIATBbdvIOQMcgE0dUF7K5DqXhXw5qv2YXenTBLaA2yR25ngRoeP3TrGVDx/KPkYFfbk0jeFdAf7ErQaiYLGOKOC1+1XfkBY8FN0O7Y+MDllJOBnOKtjxh4aNrc3I8RaSYLQIbiUX0e2EP8AcLndhd3bPXtU669YyzaatnNFdxakHNvPBcRFGVV3bhlgXGP7gb3wOaA8i59qj/uy/wDfl/8ACj7VH/dl/wC/L/4VSs/EuhajqBsNP1rT7q8Efmm2gukeQJx820HOORz7itOgCH7VH/dl/wC/L/4Ufao/7sv/AH5f/CpqKAIftUf92X/vy/8AhR9qj/uy/wDfl/8ACpqKAKl1co1nMAsuTGw5iYdvpUv2qP8Auy/9+X/wovP+PGf/AK5t/KpqAIftUf8Adl/78v8A4Ufao/7sv/fl/wDCpqKAIftUf92X/vy/+FH2qP8Auy/9+X/wqaigCH7VH/dl/wC/L/4Ufao/7sv/AH5f/CpqKAIftUf92X/vy/8AhUc7211bSW9zC8sMqFJI3gYqykYIIxyCKtVFdzPb2cs0NtLdyRqWWCEqHkP90F2Vcn3IHvSdrajW5g6b4e0Xw9a3h0q2ullnhEby3Ms877FBCpvlLEIMnCggDJ45rd+1R/3Zf+/L/wCFc7aeLm1PVbzRLnQNU0y6isTdM101s6BCSqgmKZ8EkNgEDO0+ldRVavUnyIftUf8Adl/78v8A4UVNRSGYLoskbI4yrAgj1FcV4Z8O30HiC3up11aDT9Nt5Le0t9TngcqGKgBPJJygVcbpCznjpznsjE56TyD6Bf8ACmm3kPS7mH0Cf/E0bO4dCPVf+QNe/wDXvJ/6Cadf2uoQ/ESw1GDTpbqyk06WzlmikjH2djIjBmVmBKkA/dDH2qpqltKNJu2N9OwEDkqVjwflPH3c11XkSf8AP1L+Sf8AxNJq/wDXdW/UN1b+u553YeH/ABFoXwz8LabpunyQXdkwN+lgLVrqLKPloTNmHcXYbieSrNjk0vhjwrrti3hVtRtXDWF5qct0zzRMyLM0hjJ2YUk7hwqgDPQV6H5En/P1L+Sf/E0eRJ/z9S/kn/xNN63v1B6/16/5nDaD4TvtM07wTGNPjt5NMmme+CMg8vfDKCTg/NudlzjOTyeld/UPkSf8/Uv5J/8AE0eRJ/z9S/kn/wATQHUmoqHyJP8An6l/JP8A4mjyJP8An6l/JP8A4mgCaiofIk/5+pfyT/4mjyJP+fqX8k/+JoALz/jxn/65t/KpqqXULizmJuZSBG3BC88fSpfIk/5+pfyT/wCJoAmoqHyJP+fqX8k/+Jo8iT/n6l/JP/iaAJqKh8iT/n6l/JP/AImjyJP+fqX8k/8AiaAJqKh8iT/n6l/JP/iaPIk/5+pfyT/4mgCaiofIk/5+pfyT/wCJo8iT/n6l/JP/AImgDm/DmmX0Gnaxq2uW/wBn1TVpXllh3h/IiUFIY8qSOEAJwSNzNXVVUuoXFnMTcykCNuCF54+lS+RJ/wA/Uv5J/wDE0ATUVD5En/P1L+Sf/E0UAcr4jgluPD16sF5cWbLCz+ZbMFcgAnbkgkZ6ZGGHYg81z4WTXJ9C0u8vr2GF9IN5Iba7kgkmkHlqCXQhiBvYkZwSRnOOOsnMM8EkMySNHIpRgI25BGD0FZWoaJo2o2drbXNveKlmuyBrZ7iF0XG0rvjIYggDIJwcDPSkt3/Xf/NP5D7f12/yZBpF3c33w5juL6YzztYuHmIA80hSN+BxzjPbr0FTaquuP8ULhfDs+n28v9ixM8t9C8y8TS4UIjJ1P8W7jH3Tnia8ntLfQZ7W1glhijtmjjjW1dVQBcAD5cACtLWfDGga9fi+1G1vPtYh8gT281zbyeVkkpujKnaSxyOh4znAwSu5Jrz/ACa/US+Gz8vzTMPS/GGveLltl8Orp2mSf2Tb6hcNf28lwGeYuFjQK8eAPLbLknqPlrO1r4oXkHhm01jTvssb/wBmpqFxYf2fc3rYbJKmWLCQL8rBZHyG5OAFOes1Dwr4e1JrZprK6gNtB9mjNjJcWv7nj90fKK7k4GFOQPTk1Dqfgvwvq/F5pk4jNsto8Nu9xBHJCudqOkZVXC7jt3A7c8YqtL/P/P8A4AK3X+tv+CVtCm12b4leIEutTt5dNihtmjtRbOGQOHxtYylQePmO35uPu4rsqx00rSo/EDa1FDdx3zwrA7I86pIi527owdjEbjgkEjPWtL7VH/dl/wC/L/4UhK/UmoqH7VH/AHZf+/L/AOFH2qP+7L/35f8AwoGTUVD9qj/uy/8Afl/8KPtUf92X/vy/+FABef8AHjP/ANc2/lU1VLq5RrOYBZcmNhzEw7fSpftUf92X/vy/+FAE1FQ/ao/7sv8A35f/AAo+1R/3Zf8Avy/+FAE1FQ/ao/7sv/fl/wDCj7VH/dl/78v/AIUATUVD9qj/ALsv/fl/8KPtUf8Adl/78v8A4UATVl+JotVn8L6lH4elWHVGtnFq7EDEmOOSCB9SMVe+1R/3Zf8Avy/+FRXLQXdrLby/alSVCjGISxuAR2ZcMp9wQRSeqsNOzucL4TuryDxJrmkPbazaWsWlwXH2fWL8XkqSs0qlhIJZcKwUfKW6oSFGcn0WsKx0nS9D0+9TTYLkPcgvNNcNNPLKwXALyyFmbAAAyeB0xWv9qj/uy/8Afl/8Kpu5KRNRUP2qP+7L/wB+X/wopDOc1bVItH0yW9nhuJ1jH+rtoTI7H0wOB9SQo6kgc1S1HxPaabodtqktteSxXKoyJDAXKhgDlj91QAe5GcYGSQDoanC9xpN3DCu6SSB0UZxklSBWNqGlXk/w9TTIod14LSKMx7gPmXbkZzjse9C638v1B9Lef6Gxqv8AyBr3/r3k/wDQTVqbxnoVt4wj8Mz6jbx6nLD5qxNOgJ5ACYLbt5ByBjkAmquq/wDIGvf+veT/ANBNOv7XUIfiJYajBp0t1ZSadLZyzRSRj7OxkRgzKzAlSAfuhj7Uru6+f5P9Qfwv+uq/QuDxh4aNrc3I8RaSYLQIbiUX0e2EP9wud2F3ds9e1ZPiX4h6Zoi6MtjeaTdSazLtt5LnU0t4fLCsxk8wB8jICjAOWYDIrEsPD/iLQvhn4W03TdPkgu7Jgb9LAWrXUWUfLQmbMO4uw3E8lWbHJqbwz4Y1yxsPCyahbOJbHVb65ui8sTMkcouNjHZhST5icKBjPQAcXZX9AlotP63L9n8SbG91bXobc6dNa6KwjdotVi8+VvkyfLbaioC5Xc0g+ZSMV0s+vaRa6vDpVzqtlDqVwu6GykuUWaQc8qhOT0PQdjXIa14Z1e78L+M7S3tN8+p6is1onmIPMQJAM5JwOUbg46fSrllp+paZ4u1pJdA/tG11e/hvE1DzohHCqRxrtkVm37kMZZdqsCWXleSJX2U+y+/T+vkLq/X+v68zYu/Ei2niiTSJLbKR6Y+oNP5qrwr7dmGwB67iwHr60tz4w8P6dZWVzrWsafpQvYhLCl7ewxlwQDwdxVsZHKkjnrWRr+haje+K7+8trffBN4dnskfeozMz5C4Jz079PeuE1W01WCaew8mZ7S28O6fa62lrbwyyW6R+Y7ASSXEaoxBbBVZfXAOMqL097+tZfokN7u39aR/zf3HpEHjrRW1u60+91Cws9ssUdnJLeIPtvmRo48sHGfvqOM5yPWp7HxnoWo+Kr7w7a6jbvqVkFMkInQs2c5CqG3Erj5uBjIrmdT8OXGsaX41vNPsY5pNctoDp8pKBp1EC7eScrhskbsYPNbun2uo2fxC1WeTTpnsdQtbbZepJHsR4w4ZGUsHydwwQpHuKdu4r6aHQXn/HjP8A9c2/lU1Q3n/HjP8A9c2/lU1AwooooAKKKKACiiigArm7Xx1pVxba3czxXljb6IgkuZLy3MRKGPfuCH5+nZlDe1dJXmNzo+v+IH8aWknh6+0tddgQWlzdzWzRo8cIUBxHM7DLDsDx6UmNWvqdXpvimPW1vbObS9Q0q8itVuPs9+kYZ4nDBXBjd16qQQSGBHIHFdHXHabbapf6/f69qmkzaQi6WtlHb3EsUkjsGZ3f90zALyoGWyfm4HGexqv6/H/IlX/r0/zCiiikM54xOek8g+gX/Cmm3kPS7mH0Cf8AxNUvEcEtx4evVgvLizZYWfzLZgrkAE7ckEjPTIww7EHmsTUUgvPCWlNe3WqvdSWiiCDT7yWGW4lZBySjKTj1Y7BklvULv5W/G/8AkPql3v8Ap/mbeqW0o0m7Y307AQOSpWPB+U8fdzXVeRJ/z9S/kn/xNco6XcXhBo9SkWW8WxK3EiDh5BH8xHTgnNSeIPEOqaZ4rtLRpLfTdIkWP/TrjT5blJpGk2mIyJIq25+4A0gIYvx0wafxWJWsbnT+RJ/z9S/kn/xNHkSf8/Uv5J/8TXndjr3iTRrHxJdX19Z6nJ/ba6fZRG3ljWKWVoUUljK+Ix5gO0AHg888XdS8WeItAXVbK+XS9Qv7WK0uLaaGKS2ikSacxFHQvIVIKk7gxzn7vynKWqT7/wCV/wAmPq/L/O35nb+RJ/z9S/kn/wATR5En/P1L+Sf/ABNYGg6trH/CTX+g+IHsbieC1hvIrmxgeFSkjOhRkZ35BjPO7kHoMc5B8U6ubvXrbVnt7F7e2upLXT3sZ45JUjHyypdCTZICpUkRqGTeASCMlSfKr+Tf3DSu7en4nbeRJ/z9S/kn/wATWZqPhPRtYvIbvV9PtL+5gAEU91ZwyvHg5G1mQkc88VwOq/EXUtO0+wtNNvtItL46LaXkNrqCS3M2oSzEqIoh5yuSCvUlyd4zjBJ1tY8VeKbCTxBPbnSDaeH1hecSW0pku8xI8iriTEXVsE7+oBHGTTVpW/rQlO6+X5nd+RJ/z9S/kn/xNHkSf8/Uv5J/8TUwOQD60UhlS6hcWcxNzKQI24IXnj6VL5En/P1L+Sf/ABNF5/x4z/8AXNv5VNQBD5En/P1L+Sf/ABNHkSf8/Uv5J/8AE1NRQBD5En/P1L+Sf/E0eRJ/z9S/kn/xNTUUAQ+RJ/z9S/kn/wATR5En/P1L+Sf/ABNTUUAQ+RJ/z9S/kn/xNHkSf8/Uv5J/8TU1cT4bhvB4g8Y6ZPq+pXYjaBY5pZlMkZeDJKDARDk5wqhc9qVxnV3ULizmJuZSBG3BC88fSpfIk/5+pfyT/wCJrh/B81xDqXiXTrkalaRxxQzW+nareNd3ESMjAyGUvINrMhAUSNjYSdu7Fd9VEkPkSf8AP1L+Sf8AxNFTUUhnNzmGeCSGZJGjkUowEbcgjB6Cse+0HRr77J5qanCbOEwQtZ3N3blUOPlJiZSw+VeuelaerapFo+mS3s8NxOsY/wBXbQmR2PpgcD6khR1JA5qne+ITa6Xa39rpGo6hFcQ+eRaiLdEm0HLb3UZ56KSTzgUtN/6/rcfkF3Nb23h+e1hF4ypbMitNHNIx+Uj5ncEn6k/U1sajoWk6tqMV5qCajK0RQiH7TdLAxVtyloQwjbB55U9B6Cs+6uob7wzNd2r74LizaWNsEblZMg4PPQ1d1Lxlpei+IpNO1u7s9Nt1tY51vLu6WJGZ3dRH82BnCE9fw4pv4rPcS1jdbDZvDHh+4bVfPsrl01f/AI/Imefy5GwBvCZ2o/yr86gNwDnNZuseDNNuPC99pemQSvJfSwNPLqL3Fy0qJIrFGkk3sV2hgFzjk9Mmui1TxFomhxQya1rGn6dHPnyWu7pIhJ/uliM9R0qjeeOvDmn+KBoF9q1nb3ptjcES3MaBQMfKctncQdwGOgJpabf1oHmTaNo2k6B5502C78y4KmWW4ee4kYKMKu+Qs20c4XOBk4HJquvhnQxeXN1LFqNzLcxyRMbq6up1RJPviNXYiPOAPkA4AHSqNv8AEnR9T0rT7/QpIdQju9Tj06REuE3QF3ZdzBS393cBxkEHit9vEOipri6M2r2C6qwytiblPPIxu/1ed3Tnp05p/Fv6fh/kwvb8ziNb8Iak2qyNoIZLQ2UNpalNTvbB7PywwBKwoftGNwI8xh0x3Jrqv7D0ufT7621GGa6bU4kTUJPLlT7SVQJnA+7kDouK3qKBWXQhFzGBgLL/AN+X/wAKPtUf92X/AL8v/hU1FAypdXKNZzALLkxsOYmHb6VL9qj/ALsv/fl/8KLz/jxn/wCubfyqagCH7VH/AHZf+/L/AOFH2qP+7L/35f8AwqaigCH7VH/dl/78v/hR9qj/ALsv/fl/8KmooAh+1R/3Zf8Avy/+FH2qP+7L/wB+X/wqaigCH7VH/dm/78v/AIVzVr4K8OWlxezRxatI9/GYrrz9QvZhMpXb8wdyCQOAeo7EV1dYOneMNO1XxZf6BaR3BnsIw8k5QCF/m2lVOckqeDxjIIzkGlpewbK42w0PSdDt7+TTobwz3SYmuLuWe4lcKCFBklLNtGTgZwMn1NbX2qP+7L/35f8AwrB0fxhp/imLWYtMjuAunkxNLKgVJgVJDx4JJU44JAz16c10lPcCH7VH/dl/78v/AIUVNRQBzOpwvcaTdwwrukkgdFGcZJUgVzWrWN3/AMIxpmnSaLql8yWyq/8AZ1+kHlSBAuJN0qB0OTx86nHKmuqMTnpPIPoF/wAKabeQ9LuYfQJ/8TStv5/pf/Mfby/W3+RnLDd23gsQalJHJeR2Gyd4lCoziPDFQAMDOew+gpNcs9TtPHr61a+GW1u3fSRZAxTQLIjmR2K4lZRsI27jn+7w3OJdUtpRpN2xvp2AgclSseD8p4+7muq8iT/n6l/JP/iacved35/imv1EtFb+u553o/h3WvB0lmW0WTxEraDb6a32WWBfs7xFiy/vWTMb7xyuT+7GV6Ve0Dw/q3hrVvDUb2TX1vbaKdNuLi2kQJbuHjYEh2VimFIBUE8DIrtvIk/5+pfyT/4mjyJP+fqX8k/+Jp3fNzf11/zYmrq39aW/yR5/a6Drj+HdI02bSJYJdM8QrcvI00JSWDz5H8xMOTjaw4YBvaqcHg/V4tYmsdR/4SG4spdaOoiayfTvsvMwkRmMgFwCoCqwBJwuFOMCvTPIk/5+pfyT/wCJo8iT/n6l/JP/AImlH3Xdev5f5Ib10/rr/myaiofIk/5+pfyT/wCJo8iT/n6l/JP/AImgCaiofIk/5+pfyT/4mjyJP+fqX8k/+JoALz/jxn/65t/KpqqXULizmJuZSBG3BC88fSpfIk/5+pfyT/4mgCaiofIk/wCfqX8k/wDiaPIk/wCfqX8k/wDiaAJqKh8iT/n6l/JP/iaPIk/5+pfyT/4mgCaiofIk/wCfqX8k/wDiaPIk/wCfqX8k/wDiaAG6hDcXOm3MFlc/ZLmSJkiuPL3+U5BAfbkZwecZ5xXmSfD3xdHq0tnBrWm21g2jLY/bYdNkBb96WZSDdF97AktJnnccYbmvT/Ik/wCfqX8k/wDiaPIk/wCfqX8k/wDiaVtb/wBbNfqO7tb+t0/0OK8MeHvEGja34ln1aXTmsbiGFbf7HZGAPshCjapmfYqgbdpHJ5BA4ru6qXULizmJuZSBG3BC88fSpfIk/wCfqX8k/wDiaZKVtiaiofIk/wCfqX8k/wDiaKBmTRRRQBU1X/kDXv8A17yf+gmunoooAKKKKACiiigAooooAKKKKAIbz/jxn/65t/KpqKKACiiigAooooAKKKKACiiigCG8/wCPGf8A65t/KpqKKACiiigD/9k=)\r\n",
        "\r\n",
        "\r\n",
        "Für die gesamte Kategorieübersicht:\r\n",
        "\r\n",
        "* *models / research / object_detection / data / mscoco_label_map.pbtxt*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lsCKB_Q8YCbM"
      },
      "source": [
        "detection_class_indices = [3,8]"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zFn2Q969YYaf"
      },
      "source": [
        "#@title **Funktionen** initialisieren. { display-mode: \"form\" }\r\n",
        "from object_detection.utils import visualization_utils as viz_utils\r\n",
        "from object_detection.utils import ops as utils_ops\r\n",
        "import shutil\r\n",
        "\r\n",
        "def create_overlay(result,image_np,threshold=.5):\r\n",
        "  image_np_with_detections = image_np.copy()\r\n",
        "  keypoints, keypoint_scores = None, None\r\n",
        "  if 'detection_keypoints' in result:\r\n",
        "    keypoints = result['detection_keypoints'][0]\r\n",
        "    keypoint_scores = result['detection_keypoint_scores'][0]\r\n",
        "  viz_utils.visualize_boxes_and_labels_on_image_array(\r\n",
        "    image_np_with_detections[0],\r\n",
        "    result['detection_boxes'][0],\r\n",
        "    (result['detection_classes'][0]).astype(int),\r\n",
        "    result['detection_scores'][0],\r\n",
        "    category_index,\r\n",
        "    use_normalized_coordinates=True,\r\n",
        "    max_boxes_to_draw=200,\r\n",
        "    min_score_thresh=threshold,\r\n",
        "    agnostic_mode=False,\r\n",
        "    keypoints=keypoints,\r\n",
        "    keypoint_scores=keypoint_scores)\r\n",
        "  return Image.fromarray(image_np_with_detections[0])\r\n",
        "\r\n",
        "def detection(image_path,threshold=.55):\r\n",
        "  image_np = np.expand_dims(np.asarray(load_image(image_path)),axis=0)\r\n",
        "  results = model(image_np)\r\n",
        "  result = {key:value.numpy() for key,value in results.items()}\r\n",
        "  return [result,image_np]\r\n",
        "\r\n",
        "def find_focused_car(image_path,threshold=.3,padding=16):\r\n",
        "  max_area = 0\r\n",
        "  focused_car_image = None\r\n",
        "  [result,image_np] =  detection(image_path,threshold)\r\n",
        "  detection_scores = result.get('detection_scores')[0]\r\n",
        "  detection_boxes =  result.get('detection_boxes')[0]\r\n",
        "  detection_classes = result.get('detection_classes')[0]\r\n",
        "  image = Image.fromarray(image_np[0])\r\n",
        "  for i in range(len(detection_scores)):\r\n",
        "    if detection_classes[i] not in detection_class_indices:\r\n",
        "      continue\r\n",
        "    if detection_scores[i]>threshold:\r\n",
        "      x1 = image.width*detection_boxes[i][1]-padding\r\n",
        "      y1 = image.height*detection_boxes[i][0]-padding\r\n",
        "      x2 = image.width*detection_boxes[i][3]+padding\r\n",
        "      y2 = image.height*detection_boxes[i][2]+padding\r\n",
        "      if x1<0:\r\n",
        "        x1 = 0\r\n",
        "      if y1<0:\r\n",
        "        y1 = 0\r\n",
        "      if x2>image.width:\r\n",
        "        x2 = image.width\r\n",
        "      if y2>image.height:\r\n",
        "        y2 = image.height\r\n",
        "      area = (x2-x1)*(y2-y1)\r\n",
        "      if area>max_area:\r\n",
        "        max_area = area\r\n",
        "        focused_car_image = image.crop((x1,y1,x2,y2))\r\n",
        "  return focused_car_image\r\n",
        "\r\n",
        "def crop_images(image_path,output_folder_path='temp',threshold=.5,padding=16):\r\n",
        "  if os.path.exists(output_folder_path):\r\n",
        "    shutil.rmtree(output_folder_path)\r\n",
        "  os.mkdir(output_folder_path)\r\n",
        "  [result,image_np] =  detection(image_path)\r\n",
        "  detection_scores = result.get('detection_scores')[0]\r\n",
        "  detection_boxes =  result.get('detection_boxes')[0]\r\n",
        "  detection_classes = result.get('detection_classes')[0]\r\n",
        "  image = Image.fromarray(image_np[0])\r\n",
        "  for i in range(len(detection_scores)):\r\n",
        "    if detection_classes[i] not in detection_class_indices:\r\n",
        "      continue\r\n",
        "    if detection_scores[i]>threshold:\r\n",
        "      x1 = image.width*detection_boxes[i][1]-padding\r\n",
        "      y1 = image.height*detection_boxes[i][0]-padding\r\n",
        "      x2 = image.width*detection_boxes[i][3]+padding\r\n",
        "      y2 = image.height*detection_boxes[i][2]+padding\r\n",
        "      if x1<0:\r\n",
        "        x1 = 0\r\n",
        "      if y1<0:\r\n",
        "        y1 = 0\r\n",
        "      if x2>image.width:\r\n",
        "        x2 = image.width\r\n",
        "      if y2>image.height:\r\n",
        "        y2 = image.height\r\n",
        "      im_crop = image.crop((x1,y1,x2,y2))\r\n",
        "      im_crop.save(output_folder_path + '/' + str(i) +'.jpg', quality=95)"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fA7VJ7JSZCQh"
      },
      "source": [
        "# **Embedding** Modul"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3SqaHmsnZMGv"
      },
      "source": [
        "**EfficientNet**-D5 mit dem imagenet Datensatz als *Embedding* Modell verwenden.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rjTE2SsbY6cc"
      },
      "source": [
        "from tensorflow.keras.applications import EfficientNetB5 as EN5\r\n",
        "from keras import Model\r\n",
        "modelEfficientNet = EN5(weights='imagenet') \r\n",
        "embeddingModel = Model(inputs = modelEfficientNet.input, outputs = modelEfficientNet.layers[-3].output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i_tgJl0KZzK1"
      },
      "source": [
        "#@title **Funktionen** für Datenerweiterung initialisieren. { display-mode: \"form\" }\r\n",
        "from PIL import Image, ImageEnhance, ImageOps, ImageFilter\r\n",
        "import random\r\n",
        "\r\n",
        "def load_image(path,resize=True,width=456,height=456):\r\n",
        "  image = Image.open(path).convert('RGB')\r\n",
        "  if resize:\r\n",
        "    return image.resize((width,height), Image.ANTIALIAS)\r\n",
        "  return image\r\n",
        "\r\n",
        "def flip(image):\r\n",
        "  return ImageOps.flip(image.copy())\r\n",
        "\r\n",
        "def mirror(image):\r\n",
        "  return ImageOps.mirror(image.copy())\r\n",
        "\r\n",
        "def blur(image,size=2):\r\n",
        "  return image.copy().filter(ImageFilter.GaussianBlur(size))\r\n",
        "\r\n",
        "def rotate(image,angle):\r\n",
        "  return image.copy().rotate(angle)\r\n",
        "\r\n",
        "def enhance(image,factor=0.5):\r\n",
        "  enhancer = ImageEnhance.Brightness(image.copy())\r\n",
        "  return enhancer.enhance(factor)\r\n",
        "\r\n",
        "def add_noise(image,propability=0.05):\r\n",
        "  image_clone = image.copy()\r\n",
        "  for x in range(image_clone.width):\r\n",
        "    for y in range(image_clone.height):\r\n",
        "      if random.random() < propability:\r\n",
        "        image_clone.putpixel(xy=(x,y),value=0)\r\n",
        "  return image_clone"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1qDxGQhPaDxh"
      },
      "source": [
        "**Methoden** für die Erweiterung des Datensatzes auswählen."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mn9sPMX4aDIL"
      },
      "source": [
        "def data_augmentation_batch(image):\r\n",
        "  batch_names = []\r\n",
        "  batch = []\r\n",
        "  batch.append(np.asarray(image))\r\n",
        "  batch_names.append('Base')\r\n",
        "  batch.append(np.asarray(mirror(image)))\r\n",
        "  batch_names.append('Mirror')\r\n",
        "  batch.append(np.asarray(add_noise(image)))\r\n",
        "  batch_names.append('Noise')\r\n",
        "  batch.append(np.asarray(rotate(image,-5)))\r\n",
        "  batch_names.append('Rotate (-5°)')\r\n",
        "  batch.append(np.asarray(rotate(image,5)))\r\n",
        "  batch_names.append('Rotate (+5°)')\r\n",
        "  batch.append(np.asarray(flip(image)))\r\n",
        "  batch_names.append('Flip')\r\n",
        "  batch.append(np.asarray(blur(image)))\r\n",
        "  batch_names.append('Blur')\r\n",
        "  batch.append(np.asarray(enhance(image,0.8)))\r\n",
        "  batch_names.append('Enhance (0.8)')\r\n",
        "  batch.append(np.asarray(enhance(image,1.2)))\r\n",
        "  batch_names.append('Enhance (1.2)')\r\n",
        "  return [batch,batch_names]"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rj_-B6xwacuw"
      },
      "source": [
        "#@title **Funktionen** für den *Embedding Process* initialisieren. { display-mode: \"form\" }\r\n",
        "import csv\r\n",
        "import os\r\n",
        "import numpy as np\r\n",
        "from IPython.display import HTML, display, clear_output\r\n",
        "import time\r\n",
        "\r\n",
        "def create_columns(size):\r\n",
        "  columns = []\r\n",
        "  columns.append('category')\r\n",
        "  for i in range(size):\r\n",
        "    columns.append('n' + str(i))\r\n",
        "  return columns\r\n",
        "\r\n",
        "def create_csv_file(output_file_name,size=2048):\r\n",
        "  with open(output_file_name, 'w', newline='') as file:\r\n",
        "    writer = csv.writer(file)\r\n",
        "    writer.writerow(create_columns(size))\r\n",
        "\r\n",
        "def write_to_csv(output_file_name,data):\r\n",
        "  with open(output_file_name, 'a') as file:\r\n",
        "    writer = csv.writer(file)\r\n",
        "    writer.writerow(data)\r\n",
        "\r\n",
        "def read_csv(file_name,categories=None,remove_header_row=True):\r\n",
        "  with open(file_name, 'r') as csvfile:\r\n",
        "    reader = csv.reader(csvfile, delimiter=',', quotechar='|')\r\n",
        "    X = []\r\n",
        "    Y = []\r\n",
        "    for row in reader:\r\n",
        "      if remove_header_row:\r\n",
        "        remove_header_row = False\r\n",
        "        continue\r\n",
        "      Y.append(row[0])\r\n",
        "      X.append(row[1:])\r\n",
        "  return [X,Y]\r\n",
        "\r\n",
        "def convert_labels_to_number(Y):\r\n",
        "  label_index = 0\r\n",
        "  categories = set(Y)\r\n",
        "  for category in categories:\r\n",
        "    for i in range(len(Y)):\r\n",
        "      if Y[i] == category:\r\n",
        "        Y[i] = label_index\r\n",
        "    label_index = label_index + 1\r\n",
        "  return categories\r\n",
        "\r\n",
        "def calculate_estimate_time_for_single_image(image_path,auto_crop):\r\n",
        "  start_time = time.time()\r\n",
        "  if auto_crop:\r\n",
        "    image = find_focused_car(image_path,.25,0)\r\n",
        "  else:\r\n",
        "    image = load_image(image_path)\r\n",
        "  [batch,batch_names] = data_augmentation_batch(image)\r\n",
        "  for i in range(len(batch)):\r\n",
        "    embeddingModel.predict(np.expand_dims(batch[i],axis=0))\r\n",
        "  return time.time()-start_time\r\n",
        "\r\n",
        "def count_number_of_images(dataset_path):\r\n",
        "  image_count = 0\r\n",
        "  categories = next(os.walk(dataset_path))[1]\r\n",
        "  for category in categories:\r\n",
        "    category_path = os.path.join(dataset_path,category)\r\n",
        "    image_count += len(os.listdir(category_path))\r\n",
        "  return image_count\r\n",
        "\r\n",
        "def generate_embeddings(database_file_path,dataset_path,auto_crop=False):\r\n",
        "  if not os.path.exists(database_file_path):\r\n",
        "    create_csv_file(database_file_path)\r\n",
        "  number_of_images = count_number_of_images(dataset_path)\r\n",
        "  base_time = -1\r\n",
        "  calculate_base_time = True\r\n",
        "  categories = next(os.walk(dataset_path))[1]\r\n",
        "  for category in categories:\r\n",
        "    category_path = os.path.join(dataset_path,category)\r\n",
        "    files_in_category = os.listdir(category_path)\r\n",
        "    for filename in files_in_category:\r\n",
        "      clear_output()\r\n",
        "      image_path = os.path.join(category_path,filename)\r\n",
        "      if calculate_base_time:\r\n",
        "        calculate_estimate_time_for_single_image(image_path,auto_crop)\r\n",
        "        base_time = calculate_estimate_time_for_single_image(image_path,auto_crop)\r\n",
        "        calculate_base_time = False\r\n",
        "      print('Number of images remaining: ' + str(number_of_images))\r\n",
        "      print('Estimated time remaining : ' + str(round(base_time*number_of_images/60)) + ' minutes')\r\n",
        "      number_of_images -= 1\r\n",
        "      image = None\r\n",
        "      if auto_crop:\r\n",
        "        image = find_focused_car(image_path,.25,0)\r\n",
        "      else:\r\n",
        "        image = load_image(image_path)\r\n",
        "      if image is None:\r\n",
        "        continue\r\n",
        "      # -------------------- Datenerweiterung ---------------------------\r\n",
        "      [batch,batch_names] = data_augmentation_batch(image)\r\n",
        "      # -------------------- Datenerweiterung ---------------------------\r\n",
        "      for i in range(len(batch)):\r\n",
        "        write_to_csv(database_file_path,[category] + list(embeddingModel.predict(np.expand_dims(batch[i],axis=0))[0]))"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1WR8Xol7awwx"
      },
      "source": [
        "# Bestehenden **Daten**satz verwenden. \r\n",
        "**ZIP**-Datei hochladen ...\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SgSVtVCLay35"
      },
      "source": [
        "from google.colab import files\r\n",
        "import zipfile\r\n",
        "uploaded = files.upload()\r\n",
        "for fn in uploaded.keys():\r\n",
        "  zip_file_name = fn\r\n",
        "dataset_folder = 'dataset'\r\n",
        "with zipfile.ZipFile(zip_file_name, 'r') as zip_ref:\r\n",
        "    zip_ref.extractall(dataset_folder)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KePtZLGXdHQg"
      },
      "source": [
        "... oder bestehende **CSV** Datenbank verwenden."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mp2HnsgxdN_c"
      },
      "source": [
        "csv_databaset_path = 'database.csv'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FsCcGixKdtV9"
      },
      "source": [
        "# **Daten**satz mit Bing Bildersuche erstellen."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xoxt8tffdyTa"
      },
      "source": [
        "pip install bing-image-downloader"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6RAVe-iAd0GR"
      },
      "source": [
        "number_of_images_per_class = 100\r\n",
        "car_models = [\r\n",
        "   'Mercedes benz EQC',\r\n",
        "   'Renault ZOE LIFE R110 Z.E'           \r\n",
        "]"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iw7LJgZNd3Mj"
      },
      "source": [
        "#@title **Bilder** suchen. { display-mode: \"form\" }\r\n",
        "from bing_image_downloader import downloader\r\n",
        "dataset_folder = 'dataset'\r\n",
        "for car_model in car_models:\r\n",
        "  downloader.download(car_model, limit=number_of_images_per_class,  output_dir=os.path.join(dataset_folder,'Datensatz'), adult_filter_off=True, force_replace=False, timeout=60)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sRs5Pj6Ge_LX"
      },
      "source": [
        "# **Embeddings** erstellen."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p8TemxgyfAhc",
        "outputId": "abe3a247-9f98-41ca-9189-306abf070d04"
      },
      "source": [
        "# auto_crop auf True setzen falls Bing Bildersuche verwendet oder der Datensatz noch nicht zugeschnitten wurde.\r\n",
        "ds_folder = 'dataset'\r\n",
        "generate_embeddings('database.csv',ds_folder,auto_crop=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Estimated time : 20 minutes\n",
            "Base done!\n",
            "Mirror done!\n",
            "Noise done!\n",
            "Rotate (-5°) done!\n",
            "Rotate (+5°) done!\n",
            "Flip done!\n",
            "Blur done!\n",
            "Enhance (0.8) done!\n",
            "Enhance (1.2) done!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "701_ynd3kRd0"
      },
      "source": [
        "# **Logistic** Regression Modul."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fjZnh_avkWNf"
      },
      "source": [
        "from sklearn.linear_model import LogisticRegression\r\n",
        "\r\n",
        "def create_logistic_regressor(X,Y,solver='liblinear'):\r\n",
        "  logistic_regressor = LogisticRegression(solver=solver, random_state=0)\r\n",
        "  logistic_regressor.fit(X, Y)\r\n",
        "  return logistic_regressor\r\n",
        "\r\n",
        "def logistic_regressor_predicition(image_path,categories):\r\n",
        "  embedding = embeddingModel.predict(np.expand_dims(np.asarray(load_image(image_path)),axis=0))\r\n",
        "  return categories[logistic_regressor.predict(embedding)[0]]"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qPyUZKLmkZBR"
      },
      "source": [
        "[X,Y] = read_csv('database.csv')\r\n",
        "categories = list(convert_labels_to_number(Y))\r\n",
        "logistic_regressor = create_logistic_regressor(X,Y)"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vB7xG-vCf-Ap"
      },
      "source": [
        "# **Telegram** Bot."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_8AikiElgANn"
      },
      "source": [
        "# Insert your token here\r\n",
        "TOKEN = ''"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "99pun23_gBWT"
      },
      "source": [
        "#@title **Bot** initialisieren. { display-mode: \"form\" }\r\n",
        "!pip install pyTelegramBotAPI\r\n",
        "import telebot\r\n",
        "bot = telebot.TeleBot(TOKEN)\r\n",
        "\r\n",
        "@bot.message_handler(func=lambda message: True, content_types=['photo'])\r\n",
        "def default_command(message):\r\n",
        "    image = bot.get_file(message.photo[-1].file_id)\r\n",
        "    downloaded_file = bot.download_file(image.file_path)\r\n",
        "    with open(\"image.jpg\", 'wb') as new_file:\r\n",
        "        new_file.write(downloaded_file)\r\n",
        "    crop_images('image.jpg','temp',0.3,0)\r\n",
        "    for filename in os.listdir('temp'):\r\n",
        "      image_path = os.path.join('temp',filename)\r\n",
        "      prediction = logistic_regressor_predicition(image_path,categories)\r\n",
        "      bot.send_photo(message.chat.id, photo=open(image_path, 'rb'))\r\n",
        "      bot.reply_to(message, prediction)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pB_vgYVTgC5J"
      },
      "source": [
        "#@title **Bot** starten. { display-mode: \"form\" }\r\n",
        "bot.polling()"
      ],
      "execution_count": 30,
      "outputs": []
    }
  ]
}