diff --git a/.gitignore b/.gitignore index 68bc17f..4761445 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +**/models/ + + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/requirements_mac.txt b/requirements_mac.txt new file mode 100644 index 0000000..0bf2c3a --- /dev/null +++ b/requirements_mac.txt @@ -0,0 +1,136 @@ +absl-py==1.3.0 +addict==2.4.0 +anyio==3.6.2 +appnope==0.1.3 +argon2-cffi==21.3.0 +argon2-cffi-bindings==21.2.0 +asttokens==2.1.0 +astunparse==1.6.3 +attrs==22.1.0 +backcall==0.2.0 +beautifulsoup4==4.11.1 +black==22.10.0 +bleach==5.0.1 +cachetools==5.2.0 +certifi==2022.9.24 +cffi==1.15.1 +charset-normalizer==2.1.1 +click==8.1.3 +contourpy==1.0.6 +cycler==0.11.0 +debugpy==1.6.3 +decorator==5.1.1 +defusedxml==0.7.1 +entrypoints==0.4 +executing==1.2.0 +fastapi==0.85.1 +fastjsonschema==2.16.2 +flatbuffers==1.12 +fonttools==4.38.0 +gast==0.4.0 +google-auth==2.14.1 +google-auth-oauthlib==0.4.6 +google-pasta==0.2.0 +grpcio==1.50.0 +h11==0.14.0 +h5py==3.7.0 +idna==3.4 +IProgress==0.4 +ipykernel==6.17.0 +ipython==8.6.0 +ipython-genutils==0.2.0 +ipywidgets==8.0.2 +jedi==0.18.1 +Jinja2==3.1.2 +jsonschema==4.16.0 +jstyleson==0.0.2 +jupyter-server==1.21.0 +jupyter_client==7.4.4 +jupyter_core==4.11.2 +jupyterlab-pygments==0.2.2 +jupyterlab-widgets==3.0.3 +keras==2.9.0 +Keras-Preprocessing==1.1.2 +kiwisolver==1.4.4 +libclang==14.0.6 +Markdown==3.4.1 +MarkupSafe==2.1.1 +matplotlib==3.6.1 +matplotlib-inline==0.1.6 +mistune==2.0.4 +mypy-extensions==0.4.3 +nbclassic==0.4.7 +nbclient==0.7.0 +nbconvert==7.2.3 +nbformat==5.7.0 +nest-asyncio==1.5.6 +networkx==2.8 +notebook==6.5.2 +notebook_shim==0.2.0 +numpy==1.23.1 +oauthlib==3.2.2 +opencv-python==4.6.0.66 +openvino @ file:///Users/chepe/hackerdojo/pythonista/openvino/build/wheels/openvino-2022.3.0-000-cp310-cp310-macosx_12_0_arm64.whl +openvino-dev @ file:///Users/chepe/hackerdojo/pythonista/openvino/build/wheels/openvino_dev-2022.3.0-000-py3-none-any.whl +openvino-telemetry==2022.1.1 +opt-einsum==3.3.0 +packaging==21.3 +pandas==1.1.5 +pandocfilters==1.5.0 +parso==0.8.3 +pathspec==0.10.1 +pexpect==4.8.0 +pickleshare==0.7.5 +Pillow==9.3.0 +platformdirs==2.5.2 +progress==1.6 +prometheus-client==0.15.0 +prompt-toolkit==3.0.31 +protobuf==3.19.6 +psutil==5.9.3 +ptyprocess==0.7.0 +pure-eval==0.2.2 +py-cpuinfo==9.0.0 +pyasn1==0.4.8 +pyasn1-modules==0.2.8 +pycparser==2.21 +pydantic==1.10.2 +Pygments==2.13.0 +pyparsing==3.0.9 +pyrsistent==0.19.1 +python-dateutil==2.8.2 +pytz==2022.6 +PyYAML==6.0 +pyzmq==24.0.1 +requests==2.28.1 +requests-oauthlib==1.3.1 +rsa==4.9 +scipy==1.9.3 +Send2Trash==1.8.0 +six==1.16.0 +sniffio==1.3.0 +soupsieve==2.3.2.post1 +stack-data==0.6.0 +starlette==0.20.4 +tensorboard==2.9.1 +tensorboard-data-server==0.6.1 +tensorboard-plugin-wit==1.8.1 +tensorflow-estimator==2.9.0 +tensorflow-macos==2.9.2 +termcolor==2.1.0 +terminado==0.17.0 +texttable==1.6.4 +tinycss2==1.2.1 +tomli==2.0.1 +tornado==6.2 +tqdm==4.64.1 +traitlets==5.5.0 +typing_extensions==4.4.0 +urllib3==1.26.12 +uvicorn==0.18.3 +wcwidth==0.2.5 +webencodings==0.5.1 +websocket-client==1.4.1 +Werkzeug==2.2.2 +widgetsnbextension==4.0.3 +wrapt==1.14.1 diff --git a/session_1/README.md b/session_1/README.md index 61dd20c..eada87a 100644 --- a/session_1/README.md +++ b/session_1/README.md @@ -32,7 +32,7 @@ python3 -m venv ~/.virtualenvs/hd-python Activate the virtual environment (Linux & Mac): ``` -source ~/.virtualenv/hd-pythn/bin/activate +source ~/.virtualenvs/hd-python/bin/activate ``` or run the script (Windows only): ``` diff --git a/session_2/README.md b/session_2/README.md index 4c10750..c1c898e 100644 --- a/session_2/README.md +++ b/session_2/README.md @@ -15,6 +15,15 @@ If this is your first time developing with python, follow the steps below: - About [Black](https://black.readthedocs.io/en/stable/) formatter and why its awesome. - Have a virtual environment already configured as an interpreter for your project. - For this, you can try completing all the steps from [Session 1](../session_1/README.md). +- Activate your virtual envirnoment and install Jupyter Notebook. + +``` +source ~/.virtualenvs/hd-python/bin/activate +pip install notebook +``` +- Open VS Code and make sure you are using the interpreter from your virtual environment. +- Install the Jupyter VS Code extension (by Microsoft). + ## Overview of the building blocks @@ -32,7 +41,6 @@ Some of the concepts we will glance over are: - Functions. - Classes and magic *dunder* methods (double underscore methods). - Modules, packages and the import system. -- A few, very useful, *advanced-ish* concepts (context managers, decorators, iterators/generators) Depending on the type of a variable, it will behave differently when used in combination with the different operators that exist in python. You can take a look at al the operators available here: @@ -51,7 +59,20 @@ There are a few more types available, and you may find an interesting read at th - Dict (`dict`) - String (`str`) -Please take a look at the [Session 2 Notebook](./Session_2.ipynb) to take a look at interesting things we can do with each type. +### Modern Python: Type hints + +It is a fact that a trend in the industry is to provide some typing information as we write code. This helps us prevent and catch errors before we actually run our code, as well as (sometimes) make it execute faster (ie. typescript vs javascript) or provide functionality that would be very hard to implement without typing information. + +Since Python 3.5, you can add type hints to your code by importing the definitions in the [typing](https://docs.python.org/3/library/typing.html) module. Starting on Python 3.10, there is no need to import anything as it is becoming a fundamental part of the language. + +I recommend that you enable your linter to warn you about typing information and use them as much as possible. To do this, go to the settings page in VS Code (Mac: `cmd + ,` Win,Linux: `crtl + ,`), write `type checking` and select the corresponding option in the + +Personally, I have a `strict` setting for my projects, but if you just want to get your feet wet and see what this type hints are all about you may start with the `basic` setting. + +![Alt text](./assets/type_checking.png "Enable type checking") + +Please take a look at the [Session 2 Notebook](./Session_2.ipynb) to take a look at interesting things we can do with each type and the corresponding hints. + ## Scopes and lifetimes @@ -132,22 +153,135 @@ my_func(a=1, 2) ### Pitfalls: Mutable types as default values (don't do it) +When you run a Python script or import it as a module, all the top level statements will be evaluated. That includes any global variable initialization, function calls and function definitions. As everything else in Python, a function is an object that exists during the lifetime of a program, and as any other object, some of it's members have values assigned. This is the case of the default values for `keyword` arguments. + +For most default values, this is great: whenever someone invokes a function without passing a value, the default will be used. The problem arises when the type of this default value is a mutable type (list, dict, etc) and said value is modified inside the function. The next time that function is called, the default value will be different from the first time: + +``` +def func(key, value, d = {}): + d[key] = value + return d +``` + +When we call it the first time, the result is what we expect: + +``` +func('first', 1) +``` +this outputs `{'first': 1}` + +And when we call it the second time: +``` +func('second', 2) +``` + +We would expect to see `{'second': 2}`, however, what we get is: + + ``` + { + 'first': 1, + 'second': 2 +} +``` + +This behavior is a consequence of the fudamental design of the Python language and, arguably, can be a *useful* feature (ie. memoization). However, there are much better way to implement this kind of behaviors whenever we intend to. + +If you need to use a mutable type for a function, my recommendation is that you use an invalid value as the default and then assign it to the variable when the function execution starts. A common idiom for this very common case is a shorthand for: + +``` +if d == None + d = {} +``` +has an equivalent as: + +``` +d = d or {} +``` + +So now, our function looks like this: + +``` +def func(key, value, d = None): + d = d or {} + + d[key] = value + return d +``` + +and after calling it 2 times, the result is what we expect: + +``` +func('first', 1) +func('second', 2) +``` +Now the result is the expected `{'second': 2}` + ## Classes A class allow us to define our own types. The syntax is very simple and similar to other languages. It allows us to group together several related functions and data. Some people like OOP, others prefer using only functions. The good thing is that Python allows you to use one or the other (or both) whenever you want. For this section, take a look at the [notebook](./Session_2.ipynb). -## Modules and the import system -The import system is a Python component that allows us to package (and publish) fractions of our code. A module is the next level of grouping after functions and classes +### Magic *dunder* methods + +A *dunder* method (special methods or Double Underscore Method) is a method defined inside a class with [special behavior](https://docs.python.org/3/reference/datamodel.html#specialnames), suche methods' name starts and ends with `__` (double underscore, thus the *dunder* moniker). + +There's a special magic that can happen when a certain method is implemented: It allows us to use standard features of Python with our custom objects. There are many *dunder* methods available, but some of the ones I find very useful are: + +- Initialization: `__init__` +- String representation methods: `__str__` and `__repr__` +- Hash: `__hash__` +- Sorting and comparison: `__lt__`, `__lte__`, `__gt__`, `__gte__` + +### Hack: Get free out-of-the-box functionality with `dataclass` + +The `dataclass` decorator is part of the standard library (meaning: you have it already) and provides automatically generated *dunder* methods that make your life easy and save you precious developer time. + +One feature that I find particularly useful is the ability to compare (and sort) objects out of the box, based on the existing members. + +Check out the [Official Documentation for dataclasses](https://docs.python.org/3/library/dataclasses.html) and also the examples provided in the [notebook](./Session_2.ipynb). + +### Better Hack: Pydantic + +[Pydantic](https://pydantic-docs.helpmanual.io) is a library that takes these concepts to the next level. It has an implementation for dataclasses that is a drop-in replacement for the standard library but also provide a `BaseModel` type that is great for modeling and validating data. A lot of the [FastAPI](https://fastapi.tiangolo.com) functionality introduced in [Sesion 1](../session_1/README.md) is built using Pydantic to provide the magic. We will take a deeper look at pydantic in the 3rd session. + + +## Modules, packages and the import system + +The import system is a Python component that allows us to package (and publish) fractions of our code. A module is the next level of grouping after functions and classes as it allows the programmer to put multiple class definitions and functionality together in a file. And what do we get if we create a directory and put several modules in there? That would be a `package` and as the name suggests, with just a few extra steps it can be packaged for publishing and distribution. + +It is important to know that every time the interpreter runs an `import` statement, all the top level lines will run (as we saw on the `functions` section). But also, if we do the same import in multiple places in our program, it will only run once (under most circumstances). + +If we want our module to be able to run as a script, we can use the following lines (that I'm sure you've seen if this is not your first day playing with Python): + +``` +if __name__ == "__main__": + # Do stuff when invoked with `python myscript.py` + ... +``` + +When a Python module or package is imported, `__name__` is set to the module’s name. Usually, this is the name of the Python file itself without the .py extension. However, if the module is executed in the top-level code environment, its __name__ is set to the string '__main__'. This way, we can prevent some of the code from running when using the file as a module, but execute some special things for us when invoked as top-level by the interpreter. + +Depending on the version of Python you are using, you might need to include a `__init__.py` file as part of your package. I recommend that you always create this file. In many cases this item can be empty and is just used as a marker, but if your package is more complex, you might want to isolate the user of your library from some parts of your code and provide a more useful interface for them to use. + +So, in our project, we might have a combination of modules and libraries that looks like this: + +``` +project_folder + | main.py # Entry point + |-firstmodule.py # Some functionality in a module + |-mypackage # Some extra functionality in a package + |-__init__.py # Marker file + |-secondmodule.py # Actual implementations +``` -## Bonus: Context Managers, Generators, Decorators +## Putting it all together: Custom inferencing library using ***Intel's OpenVINO*** -A brief summary of these very useful concepts. +We will define a single class `Witi` (What is this image?) that loads a pre trained model when we create an instance so we can call a `predict` method and get a description for an image we give it. -## Putting it all together: Inferencing library using Intel's OpenVINO +As always, take a look at the [notebook](./Session_2.ipynb) to see how this is done and also look at the code in this repo. ## Thanks to Intel diff --git a/session_2/Session_2.ipynb b/session_2/Session_2.ipynb index da1d4d9..e99ad6a 100644 --- a/session_2/Session_2.ipynb +++ b/session_2/Session_2.ipynb @@ -23,10 +23,170 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, World\n" + ] + } + ], + "source": [ + "print(\"Hello, World\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "a = True\n", + "b = False" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a and b" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a or b" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not a" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not b" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a == b" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 < 2" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 >= 2" + ] }, { "cell_type": "markdown", @@ -35,6 +195,488 @@ "### Numeric types: `int`, `float` and `Decimal`" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from decimal import Decimal\n", + "\n", + "a = Decimal(1)\n", + "print(type(a))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "a = 1.2345" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Collections: `list`, `dict`, `tuple`, `set`" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3]\n" + ] + } + ], + "source": [ + "l = [1,2,3]\n", + "print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['word', 1, 2, 3, 10, 10]\n" + ] + } + ], + "source": [ + "l = ['word'] + l\n", + "print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "d = {\n", + " \"one\": 1\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a': 1, 1: 'a', (1,): 'list'}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{\n", + " \"a\":1,\n", + " 1: \"a\",\n", + " (1,) : 'list'\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "a = (1,2,3,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1, 2, 3, 4}\n" + ] + } + ], + "source": [ + "s = set([1,2,3,4,1,2,3,4])\n", + "print(s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Strings: `str`" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "a = \"this is some text\"" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not here\n" + ] + } + ], + "source": [ + "my_word = 'Jose'\n", + "\n", + "if my_word in a:\n", + " print(f\"my word {my_word} is in the string 'a'\")\n", + "\n", + "else:\n", + " print(\"Not here\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'My number is : 1.23'" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 1.234567\n", + "f\"My number is : {a:.2f}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "global_var = 1\n", + "\n", + "def func(local_var):\n", + " return local_var" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func(global_var)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loops" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n" + ] + } + ], + "source": [ + "counter = 0\n", + "while(counter < 10):\n", + " print(\"counting...\")\n", + " counter += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "My item is 1\n", + "My item is 2\n", + "My item is 3\n", + "My item is 4\n", + "My item is 4\n", + "My item is 56\n" + ] + } + ], + "source": [ + "l = [1,2,3,4,4,56]\n", + "for item in l:\n", + " print(f\"My item is {item}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 4, 56]" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 4, 56]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[3:]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3, 4, 4]" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[1:-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 4, 56]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3]" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s is a fancy string\n", + "gnirts ycnaf a si sihT\n" + ] + } + ], + "source": [ + "a = \"This is a fancy string\"\n", + "\n", + "print(a[3:])\n", + "\n", + "print(a[::-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 4, 56]\n", + "[1, 3, 4]\n", + "Ti safnysrn\n" + ] + } + ], + "source": [ + "print(l)\n", + "print(l[0:5:2])\n", + "print(a[0::2])" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n" + ] + } + ], + "source": [ + "a = []\n", + "for i in range(10):\n", + " a.append(i)\n", + "\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "{1, 2, 3, 4, 6, 7, 8, 54}\n", + "{'hello': 0, 'my': 1, 'name': 2, 'is': 3, 'Jose': 4}\n", + "['1', '3', '5', '7', '9']\n" + ] + } + ], + "source": [ + "a = [i for i in range(10)]\n", + "print(a)\n", + "\n", + "b = {c for c in [1,2,3,4,1,2,3,4,1,2,3,4,54,6,7,8]}\n", + "print(b)\n", + "\n", + "words =['hello','my','name','is','Jose']\n", + "d = {k:i for i,k in enumerate(words)}\n", + "print(d)\n", + "\n", + "a = '0123456789'\n", + "odd = [i for i in a if int(i)%2 != 0]\n", + "print(odd)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -46,7 +688,257 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Collections: `list`, `dict`, `tuple`, `set`" + "## Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "def func(a,b,c=0,d=0):\n", + " \"\"\"\n", + " This function returns the product of (a+c) * (b+d)\n", + " \"\"\"\n", + " return (a + c) * (b + d)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m This function returns the product of (a+c) * (b+d)\n", + "\u001b[0;31mFile:\u001b[0m /var/folders/7n/vf_8l1x10bn365f4bvdt0rjm0000gn/T/ipykernel_12087/942612519.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + } + ], + "source": [ + "func?" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "24\n", + "8\n", + "6\n", + "6\n" + ] + } + ], + "source": [ + "print(func(1,2))\n", + "print(func(1,2,3,4))\n", + "print(func(1,2,3))\n", + "print(func(1,2,d=4))\n", + "print(func(a=1,b=2,d=4))\n", + "# print(func(a=1,d=2)) # This line causes error" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 5]\n" + ] + } + ], + "source": [ + "a =1\n", + "\n", + "a += 1\n", + "\n", + "d = {'key': 0}\n", + "d['other_key'] = 1\n", + "\n", + "l = [1,2,3]\n", + "l.append(5)\n", + "print(l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pitfalls: Mutable types as default values" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "def func(key, value, d = {}):\n", + " d[key] = value\n", + " return d" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'key': 0}" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func('key',0)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'key': 0, 'other_key': 1}" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func('other_key', 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "def func(key, value, d = None):\n", + " d = d or {}\n", + "\n", + " d[key] = value\n", + " return d" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'second': 2}" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func('first',1)\n", + "func('second',2) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classes" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [], + "source": [ + "class Fraction:\n", + " numerator: int\n", + " denominator: int\n", + "\n", + " def __init__(self, numerator, denominator):\n", + " self.numerator = numerator\n", + " self.denominator = denominator\n", + "\n", + " def __repr__(self):\n", + " return f\"Fraction(numerator={self.numerator},denominator={self.denominator})\"\n", + "\n", + " def __lt__(self, other: 'Fraction'):\n", + " s = self.numerator/self.denominator\n", + " o = other.numerator / other.denominator\n", + " return s < o\n", + "\n", + " # def __hash__(self):\n", + " # raise NotImplemented(\"This type is not hashable\")\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraction(numerator=1,denominator=2)\n", + "291969304\n", + "291969049\n", + "False\n", + "[Fraction(numerator=1,denominator=3), Fraction(numerator=1,denominator=2)]\n", + "False\n" + ] + } + ], + "source": [ + "f = Fraction(1,2)\n", + "f2 = Fraction(1,3)\n", + "print(f)\n", + "\n", + "print(hash(f))\n", + "print(hash(f2))\n", + "print(f == f2)\n", + "\n", + "print(sorted([f,f2]))\n", + "print(f < f2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dunder Methods" ] }, { @@ -60,7 +952,57 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Strings: `str`" + "### Hack: `dataclass`" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [], + "source": [ + "from dataclasses import dataclass\n", + "\n", + "@dataclass\n", + "class Fraction2:\n", + " numerator: int\n", + " denominator: int\n", + "\n", + " def __lt__(self, other):\n", + " s = self.numerator/self.denominator\n", + " o = other.numerator / other.denominator\n", + " return s < o" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraction2(numerator=1, denominator=2)\n", + "[Fraction2(numerator=1, denominator=3), Fraction2(numerator=1, denominator=2)]\n", + "[Fraction(numerator=1,denominator=3), Fraction2(numerator=1, denominator=3), Fraction(numerator=1,denominator=2), Fraction2(numerator=1, denominator=2)]\n" + ] + } + ], + "source": [ + "f3 = Fraction2(numerator=1, denominator=2)\n", + "f4 = Fraction2(numerator=1, denominator=3)\n", + "print(f3)\n", + "print(sorted([f3,f4]))\n", + "\n", + "print(sorted([f,f2,f3,f4]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Better Hack: `pydantic`" ] }, { @@ -74,7 +1016,229 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Loops" + "# Modules and the `import system`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from mypackage.mymodule import my_func" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intel's OpenVINO: A very quick intro\n", + "\n", + "OpenVINO is a great library to get started with Machine Learning enabled applications. Take a look at the official documentation at:\n", + "\n", + "https://docs.openvino.ai/latest/index.html\n", + "\n", + "and play around with Inte's Github repos:\n", + "\n", + "https://github.com/openvinotoolkit/openvino_notebooks\n", + "\n", + "And the Open Model Zoo:\n", + "\n", + "https://github.com/openvinotoolkit/open_model_zoo\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib\n", + " Using cached matplotlib-3.6.1-cp310-cp310-macosx_11_0_arm64.whl (7.2 MB)\n", + "Collecting kiwisolver>=1.0.1\n", + " Using cached kiwisolver-1.4.4-cp310-cp310-macosx_11_0_arm64.whl (63 kB)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: numpy>=1.19 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (1.23.1)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (21.3)\n", + "Collecting contourpy>=1.0.1\n", + " Downloading contourpy-1.0.6-cp310-cp310-macosx_11_0_arm64.whl (225 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m225.9/225.9 kB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pillow>=6.2.0 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (9.3.0)\n", + "Collecting cycler>=0.10\n", + " Using cached cycler-0.11.0-py3-none-any.whl (6.4 kB)\n", + "Collecting fonttools>=4.22.0\n", + " Using cached fonttools-4.38.0-py3-none-any.whl (965 kB)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: six>=1.5 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Installing collected packages: kiwisolver, fonttools, cycler, contourpy, matplotlib\n", + "Successfully installed contourpy-1.0.6 cycler-0.11.0 fonttools-4.38.0 kiwisolver-1.4.4 matplotlib-3.6.1\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.2.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m22.3\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import Core\n", + "import cv2\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "ie = Core()\n", + "model = ie.read_model(model=\"./model/v3-small_224_1.0_float.xml\")\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")\n", + "\n", + "output_layer = compiled_model.output(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "]\n", + "outputs[\n", + "\n", + "]>" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compiled_model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The MobileNet model expects images in RGB format.\n", + "image = cv2.cvtColor(cv2.imread(filename=\"./assets/maybe_cat.jpg\"), code=cv2.COLOR_BGR2RGB)\n", + "\n", + "# Resize to MobileNet image shape.\n", + "input_image = cv2.resize(src=image, dsize=(224, 224))\n", + "\n", + "# Reshape to model input shape.\n", + "input_image = np.expand_dims(input_image, 0)\n", + "plt.imshow(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n02325366 wood rabbit, cottontail, cottontail rabbit\n" + ] + } + ], + "source": [ + "result_infer = compiled_model([input_image])[output_layer]\n", + "result_index = np.argmax(result_infer)\n", + "# Convert the inference result to a class name.\n", + "imagenet_classes = open(\"./model/imagenet_2012.txt\").read().splitlines()\n", + "\n", + "# The model description states that for this model, class 0 is a background.\n", + "# Therefore, a background must be added at the beginning of imagenet_classes.\n", + "imagenet_classes = ['background'] + imagenet_classes\n", + "\n", + "print(imagenet_classes[result_index])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What Is This Image?\n", + "Let's make a library with a simple interface for our program." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from witi import Witi" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "w = Witi()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'n02325366 wood rabbit, cottontail, cottontail rabbit'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w.predict(\"./assets/maybe_cat.jpg\")" ] }, { diff --git a/session_2/assets/dog_1.jpg b/session_2/assets/dog_1.jpg new file mode 100644 index 0000000..b10be84 Binary files /dev/null and b/session_2/assets/dog_1.jpg differ diff --git a/session_2/assets/maybe_cat.jpg b/session_2/assets/maybe_cat.jpg new file mode 100644 index 0000000..a035cdf Binary files /dev/null and b/session_2/assets/maybe_cat.jpg differ diff --git a/session_2/assets/toshi_bat.JPG b/session_2/assets/toshi_bat.JPG new file mode 100644 index 0000000..ff86531 Binary files /dev/null and b/session_2/assets/toshi_bat.JPG differ diff --git a/session_2/assets/type_checking.png b/session_2/assets/type_checking.png new file mode 100644 index 0000000..08c4f7a Binary files /dev/null and b/session_2/assets/type_checking.png differ diff --git a/session_2/model/imagenet_2012.txt b/session_2/model/imagenet_2012.txt new file mode 100644 index 0000000..a9e8c7f --- /dev/null +++ b/session_2/model/imagenet_2012.txt @@ -0,0 +1,1000 @@ +n01440764 tench, Tinca tinca +n01443537 goldfish, Carassius auratus +n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias +n01491361 tiger shark, Galeocerdo cuvieri +n01494475 hammerhead, hammerhead shark +n01496331 electric ray, crampfish, numbfish, torpedo +n01498041 stingray +n01514668 cock +n01514859 hen +n01518878 ostrich, Struthio camelus +n01530575 brambling, Fringilla montifringilla +n01531178 goldfinch, Carduelis carduelis +n01532829 house finch, linnet, Carpodacus mexicanus +n01534433 junco, snowbird +n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea +n01558993 robin, American robin, Turdus migratorius +n01560419 bulbul +n01580077 jay +n01582220 magpie +n01592084 chickadee +n01601694 water ouzel, dipper +n01608432 kite +n01614925 bald eagle, American eagle, Haliaeetus leucocephalus +n01616318 vulture +n01622779 great grey owl, great gray owl, Strix nebulosa +n01629819 European fire salamander, Salamandra salamandra +n01630670 common newt, Triturus vulgaris +n01631663 eft +n01632458 spotted salamander, Ambystoma maculatum +n01632777 axolotl, mud puppy, Ambystoma mexicanum +n01641577 bullfrog, Rana catesbeiana +n01644373 tree frog, tree-frog +n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui +n01664065 loggerhead, loggerhead turtle, Caretta caretta +n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea +n01667114 mud turtle +n01667778 terrapin +n01669191 box turtle, box tortoise +n01675722 banded gecko +n01677366 common iguana, iguana, Iguana iguana +n01682714 American chameleon, anole, Anolis carolinensis +n01685808 whiptail, whiptail lizard +n01687978 agama +n01688243 frilled lizard, Chlamydosaurus kingi +n01689811 alligator lizard +n01692333 Gila monster, Heloderma suspectum +n01693334 green lizard, Lacerta viridis +n01694178 African chameleon, Chamaeleo chamaeleon +n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis +n01697457 African crocodile, Nile crocodile, Crocodylus niloticus +n01698640 American alligator, Alligator mississipiensis +n01704323 triceratops +n01728572 thunder snake, worm snake, Carphophis amoenus +n01728920 ringneck snake, ring-necked snake, ring snake +n01729322 hognose snake, puff adder, sand viper +n01729977 green snake, grass snake +n01734418 king snake, kingsnake +n01735189 garter snake, grass snake +n01737021 water snake +n01739381 vine snake +n01740131 night snake, Hypsiglena torquata +n01742172 boa constrictor, Constrictor constrictor +n01744401 rock python, rock snake, Python sebae +n01748264 Indian cobra, Naja naja +n01749939 green mamba +n01751748 sea snake +n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus +n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus +n01756291 sidewinder, horned rattlesnake, Crotalus cerastes +n01768244 trilobite +n01770081 harvestman, daddy longlegs, Phalangium opilio +n01770393 scorpion +n01773157 black and gold garden spider, Argiope aurantia +n01773549 barn spider, Araneus cavaticus +n01773797 garden spider, Aranea diademata +n01774384 black widow, Latrodectus mactans +n01774750 tarantula +n01775062 wolf spider, hunting spider +n01776313 tick +n01784675 centipede +n01795545 black grouse +n01796340 ptarmigan +n01797886 ruffed grouse, partridge, Bonasa umbellus +n01798484 prairie chicken, prairie grouse, prairie fowl +n01806143 peacock +n01806567 quail +n01807496 partridge +n01817953 African grey, African gray, Psittacus erithacus +n01818515 macaw +n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita +n01820546 lorikeet +n01824575 coucal +n01828970 bee eater +n01829413 hornbill +n01833805 hummingbird +n01843065 jacamar +n01843383 toucan +n01847000 drake +n01855032 red-breasted merganser, Mergus serrator +n01855672 goose +n01860187 black swan, Cygnus atratus +n01871265 tusker +n01872401 echidna, spiny anteater, anteater +n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus +n01877812 wallaby, brush kangaroo +n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus +n01883070 wombat +n01910747 jellyfish +n01914609 sea anemone, anemone +n01917289 brain coral +n01924916 flatworm, platyhelminth +n01930112 nematode, nematode worm, roundworm +n01943899 conch +n01944390 snail +n01945685 slug +n01950731 sea slug, nudibranch +n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore +n01968897 chambered nautilus, pearly nautilus, nautilus +n01978287 Dungeness crab, Cancer magister +n01978455 rock crab, Cancer irroratus +n01980166 fiddler crab +n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica +n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus +n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish +n01985128 crayfish, crawfish, crawdad, crawdaddy +n01986214 hermit crab +n01990800 isopod +n02002556 white stork, Ciconia ciconia +n02002724 black stork, Ciconia nigra +n02006656 spoonbill +n02007558 flamingo +n02009229 little blue heron, Egretta caerulea +n02009912 American egret, great white heron, Egretta albus +n02011460 bittern +n02012849 crane +n02013706 limpkin, Aramus pictus +n02017213 European gallinule, Porphyrio porphyrio +n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana +n02018795 bustard +n02025239 ruddy turnstone, Arenaria interpres +n02027492 red-backed sandpiper, dunlin, Erolia alpina +n02028035 redshank, Tringa totanus +n02033041 dowitcher +n02037110 oystercatcher, oyster catcher +n02051845 pelican +n02056570 king penguin, Aptenodytes patagonica +n02058221 albatross, mollymawk +n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus +n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca +n02074367 dugong, Dugong dugon +n02077923 sea lion +n02085620 Chihuahua +n02085782 Japanese spaniel +n02085936 Maltese dog, Maltese terrier, Maltese +n02086079 Pekinese, Pekingese, Peke +n02086240 Shih-Tzu +n02086646 Blenheim spaniel +n02086910 papillon +n02087046 toy terrier +n02087394 Rhodesian ridgeback +n02088094 Afghan hound, Afghan +n02088238 basset, basset hound +n02088364 beagle +n02088466 bloodhound, sleuthhound +n02088632 bluetick +n02089078 black-and-tan coonhound +n02089867 Walker hound, Walker foxhound +n02089973 English foxhound +n02090379 redbone +n02090622 borzoi, Russian wolfhound +n02090721 Irish wolfhound +n02091032 Italian greyhound +n02091134 whippet +n02091244 Ibizan hound, Ibizan Podenco +n02091467 Norwegian elkhound, elkhound +n02091635 otterhound, otter hound +n02091831 Saluki, gazelle hound +n02092002 Scottish deerhound, deerhound +n02092339 Weimaraner +n02093256 Staffordshire bullterrier, Staffordshire bull terrier +n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier +n02093647 Bedlington terrier +n02093754 Border terrier +n02093859 Kerry blue terrier +n02093991 Irish terrier +n02094114 Norfolk terrier +n02094258 Norwich terrier +n02094433 Yorkshire terrier +n02095314 wire-haired fox terrier +n02095570 Lakeland terrier +n02095889 Sealyham terrier, Sealyham +n02096051 Airedale, Airedale terrier +n02096177 cairn, cairn terrier +n02096294 Australian terrier +n02096437 Dandie Dinmont, Dandie Dinmont terrier +n02096585 Boston bull, Boston terrier +n02097047 miniature schnauzer +n02097130 giant schnauzer +n02097209 standard schnauzer +n02097298 Scotch terrier, Scottish terrier, Scottie +n02097474 Tibetan terrier, chrysanthemum dog +n02097658 silky terrier, Sydney silky +n02098105 soft-coated wheaten terrier +n02098286 West Highland white terrier +n02098413 Lhasa, Lhasa apso +n02099267 flat-coated retriever +n02099429 curly-coated retriever +n02099601 golden retriever +n02099712 Labrador retriever +n02099849 Chesapeake Bay retriever +n02100236 German short-haired pointer +n02100583 vizsla, Hungarian pointer +n02100735 English setter +n02100877 Irish setter, red setter +n02101006 Gordon setter +n02101388 Brittany spaniel +n02101556 clumber, clumber spaniel +n02102040 English springer, English springer spaniel +n02102177 Welsh springer spaniel +n02102318 cocker spaniel, English cocker spaniel, cocker +n02102480 Sussex spaniel +n02102973 Irish water spaniel +n02104029 kuvasz +n02104365 schipperke +n02105056 groenendael +n02105162 malinois +n02105251 briard +n02105412 kelpie +n02105505 komondor +n02105641 Old English sheepdog, bobtail +n02105855 Shetland sheepdog, Shetland sheep dog, Shetland +n02106030 collie +n02106166 Border collie +n02106382 Bouvier des Flandres, Bouviers des Flandres +n02106550 Rottweiler +n02106662 German shepherd, German shepherd dog, German police dog, alsatian +n02107142 Doberman, Doberman pinscher +n02107312 miniature pinscher +n02107574 Greater Swiss Mountain dog +n02107683 Bernese mountain dog +n02107908 Appenzeller +n02108000 EntleBucher +n02108089 boxer +n02108422 bull mastiff +n02108551 Tibetan mastiff +n02108915 French bulldog +n02109047 Great Dane +n02109525 Saint Bernard, St Bernard +n02109961 Eskimo dog, husky +n02110063 malamute, malemute, Alaskan malamute +n02110185 Siberian husky +n02110341 dalmatian, coach dog, carriage dog +n02110627 affenpinscher, monkey pinscher, monkey dog +n02110806 basenji +n02110958 pug, pug-dog +n02111129 Leonberg +n02111277 Newfoundland, Newfoundland dog +n02111500 Great Pyrenees +n02111889 Samoyed, Samoyede +n02112018 Pomeranian +n02112137 chow, chow chow +n02112350 keeshond +n02112706 Brabancon griffon +n02113023 Pembroke, Pembroke Welsh corgi +n02113186 Cardigan, Cardigan Welsh corgi +n02113624 toy poodle +n02113712 miniature poodle +n02113799 standard poodle +n02113978 Mexican hairless +n02114367 timber wolf, grey wolf, gray wolf, Canis lupus +n02114548 white wolf, Arctic wolf, Canis lupus tundrarum +n02114712 red wolf, maned wolf, Canis rufus, Canis niger +n02114855 coyote, prairie wolf, brush wolf, Canis latrans +n02115641 dingo, warrigal, warragal, Canis dingo +n02115913 dhole, Cuon alpinus +n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus +n02117135 hyena, hyaena +n02119022 red fox, Vulpes vulpes +n02119789 kit fox, Vulpes macrotis +n02120079 Arctic fox, white fox, Alopex lagopus +n02120505 grey fox, gray fox, Urocyon cinereoargenteus +n02123045 tabby, tabby cat +n02123159 tiger cat +n02123394 Persian cat +n02123597 Siamese cat, Siamese +n02124075 Egyptian cat +n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor +n02127052 lynx, catamount +n02128385 leopard, Panthera pardus +n02128757 snow leopard, ounce, Panthera uncia +n02128925 jaguar, panther, Panthera onca, Felis onca +n02129165 lion, king of beasts, Panthera leo +n02129604 tiger, Panthera tigris +n02130308 cheetah, chetah, Acinonyx jubatus +n02132136 brown bear, bruin, Ursus arctos +n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus +n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus +n02134418 sloth bear, Melursus ursinus, Ursus ursinus +n02137549 mongoose +n02138441 meerkat, mierkat +n02165105 tiger beetle +n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle +n02167151 ground beetle, carabid beetle +n02168699 long-horned beetle, longicorn, longicorn beetle +n02169497 leaf beetle, chrysomelid +n02172182 dung beetle +n02174001 rhinoceros beetle +n02177972 weevil +n02190166 fly +n02206856 bee +n02219486 ant, emmet, pismire +n02226429 grasshopper, hopper +n02229544 cricket +n02231487 walking stick, walkingstick, stick insect +n02233338 cockroach, roach +n02236044 mantis, mantid +n02256656 cicada, cicala +n02259212 leafhopper +n02264363 lacewing, lacewing fly +n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk +n02268853 damselfly +n02276258 admiral +n02277742 ringlet, ringlet butterfly +n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus +n02280649 cabbage butterfly +n02281406 sulphur butterfly, sulfur butterfly +n02281787 lycaenid, lycaenid butterfly +n02317335 starfish, sea star +n02319095 sea urchin +n02321529 sea cucumber, holothurian +n02325366 wood rabbit, cottontail, cottontail rabbit +n02326432 hare +n02328150 Angora, Angora rabbit +n02342885 hamster +n02346627 porcupine, hedgehog +n02356798 fox squirrel, eastern fox squirrel, Sciurus niger +n02361337 marmot +n02363005 beaver +n02364673 guinea pig, Cavia cobaya +n02389026 sorrel +n02391049 zebra +n02395406 hog, pig, grunter, squealer, Sus scrofa +n02396427 wild boar, boar, Sus scrofa +n02397096 warthog +n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius +n02403003 ox +n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis +n02410509 bison +n02412080 ram, tup +n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis +n02417914 ibex, Capra ibex +n02422106 hartebeest +n02422699 impala, Aepyceros melampus +n02423022 gazelle +n02437312 Arabian camel, dromedary, Camelus dromedarius +n02437616 llama +n02441942 weasel +n02442845 mink +n02443114 polecat, fitch, foulmart, foumart, Mustela putorius +n02443484 black-footed ferret, ferret, Mustela nigripes +n02444819 otter +n02445715 skunk, polecat, wood pussy +n02447366 badger +n02454379 armadillo +n02457408 three-toed sloth, ai, Bradypus tridactylus +n02480495 orangutan, orang, orangutang, Pongo pygmaeus +n02480855 gorilla, Gorilla gorilla +n02481823 chimpanzee, chimp, Pan troglodytes +n02483362 gibbon, Hylobates lar +n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus +n02484975 guenon, guenon monkey +n02486261 patas, hussar monkey, Erythrocebus patas +n02486410 baboon +n02487347 macaque +n02488291 langur +n02488702 colobus, colobus monkey +n02489166 proboscis monkey, Nasalis larvatus +n02490219 marmoset +n02492035 capuchin, ringtail, Cebus capucinus +n02492660 howler monkey, howler +n02493509 titi, titi monkey +n02493793 spider monkey, Ateles geoffroyi +n02494079 squirrel monkey, Saimiri sciureus +n02497673 Madagascar cat, ring-tailed lemur, Lemur catta +n02500267 indri, indris, Indri indri, Indri brevicaudatus +n02504013 Indian elephant, Elephas maximus +n02504458 African elephant, Loxodonta africana +n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens +n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca +n02514041 barracouta, snoek +n02526121 eel +n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch +n02606052 rock beauty, Holocanthus tricolor +n02607072 anemone fish +n02640242 sturgeon +n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus +n02643566 lionfish +n02655020 puffer, pufferfish, blowfish, globefish +n02666196 abacus +n02667093 abaya +n02669723 academic gown, academic robe, judge's robe +n02672831 accordion, piano accordion, squeeze box +n02676566 acoustic guitar +n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier +n02690373 airliner +n02692877 airship, dirigible +n02699494 altar +n02701002 ambulance +n02704792 amphibian, amphibious vehicle +n02708093 analog clock +n02727426 apiary, bee house +n02730930 apron +n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin +n02749479 assault rifle, assault gun +n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack +n02776631 bakery, bakeshop, bakehouse +n02777292 balance beam, beam +n02782093 balloon +n02783161 ballpoint, ballpoint pen, ballpen, Biro +n02786058 Band Aid +n02787622 banjo +n02788148 bannister, banister, balustrade, balusters, handrail +n02790996 barbell +n02791124 barber chair +n02791270 barbershop +n02793495 barn +n02794156 barometer +n02795169 barrel, cask +n02797295 barrow, garden cart, lawn cart, wheelbarrow +n02799071 baseball +n02802426 basketball +n02804414 bassinet +n02804610 bassoon +n02807133 bathing cap, swimming cap +n02808304 bath towel +n02808440 bathtub, bathing tub, bath, tub +n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon +n02814860 beacon, lighthouse, beacon light, pharos +n02815834 beaker +n02817516 bearskin, busby, shako +n02823428 beer bottle +n02823750 beer glass +n02825657 bell cote, bell cot +n02834397 bib +n02835271 bicycle-built-for-two, tandem bicycle, tandem +n02837789 bikini, two-piece +n02840245 binder, ring-binder +n02841315 binoculars, field glasses, opera glasses +n02843684 birdhouse +n02859443 boathouse +n02860847 bobsled, bobsleigh, bob +n02865351 bolo tie, bolo, bola tie, bola +n02869837 bonnet, poke bonnet +n02870880 bookcase +n02871525 bookshop, bookstore, bookstall +n02877765 bottlecap +n02879718 bow +n02883205 bow tie, bow-tie, bowtie +n02892201 brass, memorial tablet, plaque +n02892767 brassiere, bra, bandeau +n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty +n02895154 breastplate, aegis, egis +n02906734 broom +n02909870 bucket, pail +n02910353 buckle +n02916936 bulletproof vest +n02917067 bullet train, bullet +n02927161 butcher shop, meat market +n02930766 cab, hack, taxi, taxicab +n02939185 caldron, cauldron +n02948072 candle, taper, wax light +n02950826 cannon +n02951358 canoe +n02951585 can opener, tin opener +n02963159 cardigan +n02965783 car mirror +n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig +n02966687 carpenter's kit, tool kit +n02971356 carton +n02974003 car wheel +n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM +n02978881 cassette +n02979186 cassette player +n02980441 castle +n02981792 catamaran +n02988304 CD player +n02992211 cello, violoncello +n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone +n02999410 chain +n03000134 chainlink fence +n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour +n03000684 chain saw, chainsaw +n03014705 chest +n03016953 chiffonier, commode +n03017168 chime, bell, gong +n03018349 china cabinet, china closet +n03026506 Christmas stocking +n03028079 church, church building +n03032252 cinema, movie theater, movie theatre, movie house, picture palace +n03041632 cleaver, meat cleaver, chopper +n03042490 cliff dwelling +n03045698 cloak +n03047690 clog, geta, patten, sabot +n03062245 cocktail shaker +n03063599 coffee mug +n03063689 coffeepot +n03065424 coil, spiral, volute, whorl, helix +n03075370 combination lock +n03085013 computer keyboard, keypad +n03089624 confectionery, confectionary, candy store +n03095699 container ship, containership, container vessel +n03100240 convertible +n03109150 corkscrew, bottle screw +n03110669 cornet, horn, trumpet, trump +n03124043 cowboy boot +n03124170 cowboy hat, ten-gallon hat +n03125729 cradle +n03126707 crane +n03127747 crash helmet +n03127925 crate +n03131574 crib, cot +n03133878 Crock Pot +n03134739 croquet ball +n03141823 crutch +n03146219 cuirass +n03160309 dam, dike, dyke +n03179701 desk +n03180011 desktop computer +n03187595 dial telephone, dial phone +n03188531 diaper, nappy, napkin +n03196217 digital clock +n03197337 digital watch +n03201208 dining table, board +n03207743 dishrag, dishcloth +n03207941 dishwasher, dish washer, dishwashing machine +n03208938 disk brake, disc brake +n03216828 dock, dockage, docking facility +n03218198 dogsled, dog sled, dog sleigh +n03220513 dome +n03223299 doormat, welcome mat +n03240683 drilling platform, offshore rig +n03249569 drum, membranophone, tympan +n03250847 drumstick +n03255030 dumbbell +n03259280 Dutch oven +n03271574 electric fan, blower +n03272010 electric guitar +n03272562 electric locomotive +n03290653 entertainment center +n03291819 envelope +n03297495 espresso maker +n03314780 face powder +n03325584 feather boa, boa +n03337140 file, file cabinet, filing cabinet +n03344393 fireboat +n03345487 fire engine, fire truck +n03347037 fire screen, fireguard +n03355925 flagpole, flagstaff +n03372029 flute, transverse flute +n03376595 folding chair +n03379051 football helmet +n03384352 forklift +n03388043 fountain +n03388183 fountain pen +n03388549 four-poster +n03393912 freight car +n03394916 French horn, horn +n03400231 frying pan, frypan, skillet +n03404251 fur coat +n03417042 garbage truck, dustcart +n03424325 gasmask, respirator, gas helmet +n03425413 gas pump, gasoline pump, petrol pump, island dispenser +n03443371 goblet +n03444034 go-kart +n03445777 golf ball +n03445924 golfcart, golf cart +n03447447 gondola +n03447721 gong, tam-tam +n03450230 gown +n03452741 grand piano, grand +n03457902 greenhouse, nursery, glasshouse +n03459775 grille, radiator grille +n03461385 grocery store, grocery, food market, market +n03467068 guillotine +n03476684 hair slide +n03476991 hair spray +n03478589 half track +n03481172 hammer +n03482405 hamper +n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier +n03485407 hand-held computer, hand-held microcomputer +n03485794 handkerchief, hankie, hanky, hankey +n03492542 hard disc, hard disk, fixed disk +n03494278 harmonica, mouth organ, harp, mouth harp +n03495258 harp +n03496892 harvester, reaper +n03498962 hatchet +n03527444 holster +n03529860 home theater, home theatre +n03530642 honeycomb +n03532672 hook, claw +n03534580 hoopskirt, crinoline +n03535780 horizontal bar, high bar +n03538406 horse cart, horse-cart +n03544143 hourglass +n03584254 iPod +n03584829 iron, smoothing iron +n03590841 jack-o'-lantern +n03594734 jean, blue jean, denim +n03594945 jeep, landrover +n03595614 jersey, T-shirt, tee shirt +n03598930 jigsaw puzzle +n03599486 jinrikisha, ricksha, rickshaw +n03602883 joystick +n03617480 kimono +n03623198 knee pad +n03627232 knot +n03630383 lab coat, laboratory coat +n03633091 ladle +n03637318 lampshade, lamp shade +n03642806 laptop, laptop computer +n03649909 lawn mower, mower +n03657121 lens cap, lens cover +n03658185 letter opener, paper knife, paperknife +n03661043 library +n03662601 lifeboat +n03666591 lighter, light, igniter, ignitor +n03670208 limousine, limo +n03673027 liner, ocean liner +n03676483 lipstick, lip rouge +n03680355 Loafer +n03690938 lotion +n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system +n03692522 loupe, jeweler's loupe +n03697007 lumbermill, sawmill +n03706229 magnetic compass +n03709823 mailbag, postbag +n03710193 mailbox, letter box +n03710637 maillot +n03710721 maillot, tank suit +n03717622 manhole cover +n03720891 maraca +n03721384 marimba, xylophone +n03724870 mask +n03729826 matchstick +n03733131 maypole +n03733281 maze, labyrinth +n03733805 measuring cup +n03742115 medicine chest, medicine cabinet +n03743016 megalith, megalithic structure +n03759954 microphone, mike +n03761084 microwave, microwave oven +n03763968 military uniform +n03764736 milk can +n03769881 minibus +n03770439 miniskirt, mini +n03770679 minivan +n03773504 missile +n03775071 mitten +n03775546 mixing bowl +n03776460 mobile home, manufactured home +n03777568 Model T +n03777754 modem +n03781244 monastery +n03782006 monitor +n03785016 moped +n03786901 mortar +n03787032 mortarboard +n03788195 mosque +n03788365 mosquito net +n03791053 motor scooter, scooter +n03792782 mountain bike, all-terrain bike, off-roader +n03792972 mountain tent +n03793489 mouse, computer mouse +n03794056 mousetrap +n03796401 moving van +n03803284 muzzle +n03804744 nail +n03814639 neck brace +n03814906 necklace +n03825788 nipple +n03832673 notebook, notebook computer +n03837869 obelisk +n03838899 oboe, hautboy, hautbois +n03840681 ocarina, sweet potato +n03841143 odometer, hodometer, mileometer, milometer +n03843555 oil filter +n03854065 organ, pipe organ +n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO +n03866082 overskirt +n03868242 oxcart +n03868863 oxygen mask +n03871628 packet +n03873416 paddle, boat paddle +n03874293 paddlewheel, paddle wheel +n03874599 padlock +n03876231 paintbrush +n03877472 pajama, pyjama, pj's, jammies +n03877845 palace +n03884397 panpipe, pandean pipe, syrinx +n03887697 paper towel +n03888257 parachute, chute +n03888605 parallel bars, bars +n03891251 park bench +n03891332 parking meter +n03895866 passenger car, coach, carriage +n03899768 patio, terrace +n03902125 pay-phone, pay-station +n03903868 pedestal, plinth, footstall +n03908618 pencil box, pencil case +n03908714 pencil sharpener +n03916031 perfume, essence +n03920288 Petri dish +n03924679 photocopier +n03929660 pick, plectrum, plectron +n03929855 pickelhaube +n03930313 picket fence, paling +n03930630 pickup, pickup truck +n03933933 pier +n03935335 piggy bank, penny bank +n03937543 pill bottle +n03938244 pillow +n03942813 ping-pong ball +n03944341 pinwheel +n03947888 pirate, pirate ship +n03950228 pitcher, ewer +n03954731 plane, carpenter's plane, woodworking plane +n03956157 planetarium +n03958227 plastic bag +n03961711 plate rack +n03967562 plow, plough +n03970156 plunger, plumber's helper +n03976467 Polaroid camera, Polaroid Land camera +n03976657 pole +n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria +n03980874 poncho +n03982430 pool table, billiard table, snooker table +n03983396 pop bottle, soda bottle +n03991062 pot, flowerpot +n03992509 potter's wheel +n03995372 power drill +n03998194 prayer rug, prayer mat +n04004767 printer +n04005630 prison, prison house +n04008634 projectile, missile +n04009552 projector +n04019541 puck, hockey puck +n04023962 punching bag, punch bag, punching ball, punchball +n04026417 purse +n04033901 quill, quill pen +n04033995 quilt, comforter, comfort, puff +n04037443 racer, race car, racing car +n04039381 racket, racquet +n04040759 radiator +n04041544 radio, wireless +n04044716 radio telescope, radio reflector +n04049303 rain barrel +n04065272 recreational vehicle, RV, R.V. +n04067472 reel +n04069434 reflex camera +n04070727 refrigerator, icebox +n04074963 remote control, remote +n04081281 restaurant, eating house, eating place, eatery +n04086273 revolver, six-gun, six-shooter +n04090263 rifle +n04099969 rocking chair, rocker +n04111531 rotisserie +n04116512 rubber eraser, rubber, pencil eraser +n04118538 rugby ball +n04118776 rule, ruler +n04120489 running shoe +n04125021 safe +n04127249 safety pin +n04131690 saltshaker, salt shaker +n04133789 sandal +n04136333 sarong +n04141076 sax, saxophone +n04141327 scabbard +n04141975 scale, weighing machine +n04146614 school bus +n04147183 schooner +n04149813 scoreboard +n04152593 screen, CRT screen +n04153751 screw +n04154565 screwdriver +n04162706 seat belt, seatbelt +n04179913 sewing machine +n04192698 shield, buckler +n04200800 shoe shop, shoe-shop, shoe store +n04201297 shoji +n04204238 shopping basket +n04204347 shopping cart +n04208210 shovel +n04209133 shower cap +n04209239 shower curtain +n04228054 ski +n04229816 ski mask +n04235860 sleeping bag +n04238763 slide rule, slipstick +n04239074 sliding door +n04243546 slot, one-armed bandit +n04251144 snorkel +n04252077 snowmobile +n04252225 snowplow, snowplough +n04254120 soap dispenser +n04254680 soccer ball +n04254777 sock +n04258138 solar dish, solar collector, solar furnace +n04259630 sombrero +n04263257 soup bowl +n04264628 space bar +n04265275 space heater +n04266014 space shuttle +n04270147 spatula +n04273569 speedboat +n04275548 spider web, spider's web +n04277352 spindle +n04285008 sports car, sport car +n04286575 spotlight, spot +n04296562 stage +n04310018 steam locomotive +n04311004 steel arch bridge +n04311174 steel drum +n04317175 stethoscope +n04325704 stole +n04326547 stone wall +n04328186 stopwatch, stop watch +n04330267 stove +n04332243 strainer +n04335435 streetcar, tram, tramcar, trolley, trolley car +n04336792 stretcher +n04344873 studio couch, day bed +n04346328 stupa, tope +n04347754 submarine, pigboat, sub, U-boat +n04350905 suit, suit of clothes +n04355338 sundial +n04355933 sunglass +n04356056 sunglasses, dark glasses, shades +n04357314 sunscreen, sunblock, sun blocker +n04366367 suspension bridge +n04367480 swab, swob, mop +n04370456 sweatshirt +n04371430 swimming trunks, bathing trunks +n04371774 swing +n04372370 switch, electric switch, electrical switch +n04376876 syringe +n04380533 table lamp +n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle +n04392985 tape player +n04398044 teapot +n04399382 teddy, teddy bear +n04404412 television, television system +n04409515 tennis ball +n04417672 thatch, thatched roof +n04418357 theater curtain, theatre curtain +n04423845 thimble +n04428191 thresher, thrasher, threshing machine +n04429376 throne +n04435653 tile roof +n04442312 toaster +n04443257 tobacco shop, tobacconist shop, tobacconist +n04447861 toilet seat +n04456115 torch +n04458633 totem pole +n04461696 tow truck, tow car, wrecker +n04462240 toyshop +n04465501 tractor +n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi +n04476259 tray +n04479046 trench coat +n04482393 tricycle, trike, velocipede +n04483307 trimaran +n04485082 tripod +n04486054 triumphal arch +n04487081 trolleybus, trolley coach, trackless trolley +n04487394 trombone +n04493381 tub, vat +n04501370 turnstile +n04505470 typewriter keyboard +n04507155 umbrella +n04509417 unicycle, monocycle +n04515003 upright, upright piano +n04517823 vacuum, vacuum cleaner +n04522168 vase +n04523525 vault +n04525038 velvet +n04525305 vending machine +n04532106 vestment +n04532670 viaduct +n04536866 violin, fiddle +n04540053 volleyball +n04542943 waffle iron +n04548280 wall clock +n04548362 wallet, billfold, notecase, pocketbook +n04550184 wardrobe, closet, press +n04552348 warplane, military plane +n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin +n04554684 washer, automatic washer, washing machine +n04557648 water bottle +n04560804 water jug +n04562935 water tower +n04579145 whiskey jug +n04579432 whistle +n04584207 wig +n04589890 window screen +n04590129 window shade +n04591157 Windsor tie +n04591713 wine bottle +n04592741 wing +n04596742 wok +n04597913 wooden spoon +n04599235 wool, woolen, woollen +n04604644 worm fence, snake fence, snake-rail fence, Virginia fence +n04606251 wreck +n04612504 yawl +n04613696 yurt +n06359193 web site, website, internet site, site +n06596364 comic book +n06785654 crossword puzzle, crossword +n06794110 street sign +n06874185 traffic light, traffic signal, stoplight +n07248320 book jacket, dust cover, dust jacket, dust wrapper +n07565083 menu +n07579787 plate +n07583066 guacamole +n07584110 consomme +n07590611 hot pot, hotpot +n07613480 trifle +n07614500 ice cream, icecream +n07615774 ice lolly, lolly, lollipop, popsicle +n07684084 French loaf +n07693725 bagel, beigel +n07695742 pretzel +n07697313 cheeseburger +n07697537 hotdog, hot dog, red hot +n07711569 mashed potato +n07714571 head cabbage +n07714990 broccoli +n07715103 cauliflower +n07716358 zucchini, courgette +n07716906 spaghetti squash +n07717410 acorn squash +n07717556 butternut squash +n07718472 cucumber, cuke +n07718747 artichoke, globe artichoke +n07720875 bell pepper +n07730033 cardoon +n07734744 mushroom +n07742313 Granny Smith +n07745940 strawberry +n07747607 orange +n07749582 lemon +n07753113 fig +n07753275 pineapple, ananas +n07753592 banana +n07754684 jackfruit, jak, jack +n07760859 custard apple +n07768694 pomegranate +n07802026 hay +n07831146 carbonara +n07836838 chocolate sauce, chocolate syrup +n07860988 dough +n07871810 meat loaf, meatloaf +n07873807 pizza, pizza pie +n07875152 potpie +n07880968 burrito +n07892512 red wine +n07920052 espresso +n07930864 cup +n07932039 eggnog +n09193705 alp +n09229709 bubble +n09246464 cliff, drop, drop-off +n09256479 coral reef +n09288635 geyser +n09332890 lakeside, lakeshore +n09399592 promontory, headland, head, foreland +n09421951 sandbar, sand bar +n09428293 seashore, coast, seacoast, sea-coast +n09468604 valley, vale +n09472597 volcano +n09835506 ballplayer, baseball player +n10148035 groom, bridegroom +n10565667 scuba diver +n11879895 rapeseed +n11939491 daisy +n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum +n12144580 corn +n12267677 acorn +n12620546 hip, rose hip, rosehip +n12768682 buckeye, horse chestnut, conker +n12985857 coral fungus +n12998815 agaric +n13037406 gyromitra +n13040303 stinkhorn, carrion fungus +n13044778 earthstar +n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa +n13054560 bolete +n13133613 ear, spike, capitulum +n15075141 toilet tissue, toilet paper, bathroom tissue diff --git a/session_2/model/v3-small_224_1.0_float.bin b/session_2/model/v3-small_224_1.0_float.bin new file mode 100644 index 0000000..9100605 Binary files /dev/null and b/session_2/model/v3-small_224_1.0_float.bin differ diff --git a/session_2/model/v3-small_224_1.0_float.xml b/session_2/model/v3-small_224_1.0_float.xml new file mode 100644 index 0000000..25028b4 --- /dev/null +++ b/session_2/model/v3-small_224_1.0_float.xml @@ -0,0 +1,9626 @@ + + + + + + + + + + + + + 1 + 224 + 224 + 3 + + + + + + + + + + + 4 + + + + + + + + + + 1 + 224 + 224 + 3 + + + 4 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 1 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 3 + 1 + 1 + + + + + + + + + + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 1 + 1 + + + + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 16 + 3 + 3 + 3 + + + + + + + + + + + + 16 + 3 + 3 + 3 + + + + + 16 + 3 + 3 + 3 + + + + + + + + + + + 1 + 3 + 224 + 224 + + + 16 + 3 + 3 + 3 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 112 + 112 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 112 + 112 + + + + + + + + + + 1 + 16 + 112 + 112 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 16 + 1 + 1 + 3 + 3 + + + + + + + + + + + + 16 + 1 + 1 + 3 + 3 + + + + + 16 + 1 + 1 + 3 + 3 + + + + + + + + + + + 1 + 16 + 112 + 112 + + + 16 + 1 + 1 + 3 + 3 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 56 + 56 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 8 + 16 + 1 + 1 + + + + + + + + + + + + 8 + 16 + 1 + 1 + + + + + 8 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + 8 + 16 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + + + + + + + + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + + + + 1 + 8 + 1 + 1 + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 16 + 8 + 1 + 1 + + + + + + + + + + + + 16 + 8 + 1 + 1 + + + + + 16 + 8 + 1 + 1 + + + + + + + + + + + 1 + 8 + 1 + 1 + + + 16 + 8 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 16 + 16 + 1 + 1 + + + + + + + + + + + + 16 + 16 + 1 + 1 + + + + + 16 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 16 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 72 + 16 + 1 + 1 + + + + + + + + + + + + 72 + 16 + 1 + 1 + + + + + 72 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 72 + 16 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 56 + 56 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + + + + 1 + 72 + 56 + 56 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 72 + 1 + 1 + 3 + 3 + + + + + + + + + + + + 72 + 1 + 1 + 3 + 3 + + + + + 72 + 1 + 1 + 3 + 3 + + + + + + + + + + + 1 + 72 + 56 + 56 + + + 72 + 1 + 1 + 3 + 3 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 28 + 28 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 28 + 28 + + + + + + + + + + 1 + 72 + 28 + 28 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 24 + 72 + 1 + 1 + + + + + + + + + + + + 24 + 72 + 1 + 1 + + + + + 24 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 28 + 28 + + + 24 + 72 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 88 + 24 + 1 + 1 + + + + + + + + + + + + 88 + 24 + 1 + 1 + + + + + 88 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 88 + 24 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 88 + 1 + 1 + 3 + 3 + + + + + + + + + + + + 88 + 1 + 1 + 3 + 3 + + + + + 88 + 1 + 1 + 3 + 3 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 88 + 1 + 1 + 3 + 3 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 24 + 88 + 1 + 1 + + + + + + + + + + + + 24 + 88 + 1 + 1 + + + + + 24 + 88 + 1 + 1 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 24 + 88 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 28 + 28 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + + 96 + 24 + 1 + 1 + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 28 + 28 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + + + + 1 + 96 + 28 + 28 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 96 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 96 + 1 + 1 + 5 + 5 + + + + + 96 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 96 + 28 + 28 + + + 96 + 1 + 1 + 5 + 5 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 14 + 14 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 24 + 96 + 1 + 1 + + + + + + + + + + + + 24 + 96 + 1 + 1 + + + + + 24 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + 24 + 96 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 1 + 1 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + + 96 + 24 + 1 + 1 + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 1 + 1 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 40 + 96 + 1 + 1 + + + + + + + + + + + + 40 + 96 + 1 + 1 + + + + + 40 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + 40 + 96 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + + 240 + 40 + 1 + 1 + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + + 64 + 240 + 1 + 1 + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + + 240 + 64 + 1 + 1 + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + + 40 + 240 + 1 + 1 + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + + 240 + 40 + 1 + 1 + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + + 64 + 240 + 1 + 1 + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + + 240 + 64 + 1 + 1 + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + + 40 + 240 + 1 + 1 + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 120 + 40 + 1 + 1 + + + + + + + + + + + + 120 + 40 + 1 + 1 + + + + + 120 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 120 + 40 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 120 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 120 + 1 + 1 + 5 + 5 + + + + + 120 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 120 + 1 + 1 + 5 + 5 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 32 + 120 + 1 + 1 + + + + + + + + + + + + 32 + 120 + 1 + 1 + + + + + 32 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + 32 + 120 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + + 1 + 32 + 1 + 1 + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 120 + 32 + 1 + 1 + + + + + + + + + + + + 120 + 32 + 1 + 1 + + + + + 120 + 32 + 1 + 1 + + + + + + + + + + + 1 + 32 + 1 + 1 + + + 120 + 32 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 48 + 120 + 1 + 1 + + + + + + + + + + + + 48 + 120 + 1 + 1 + + + + + 48 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 48 + 120 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 144 + 48 + 1 + 1 + + + + + + + + + + + + 144 + 48 + 1 + 1 + + + + + 144 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 144 + 48 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 144 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 144 + 1 + 1 + 5 + 5 + + + + + 144 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 144 + 1 + 1 + 5 + 5 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 40 + 144 + 1 + 1 + + + + + + + + + + + + 40 + 144 + 1 + 1 + + + + + 40 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 40 + 144 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 1 + 1 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 144 + 40 + 1 + 1 + + + + + + + + + + + + 144 + 40 + 1 + 1 + + + + + 144 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 1 + 1 + + + 144 + 40 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 48 + 144 + 1 + 1 + + + + + + + + + + + + 48 + 144 + 1 + 1 + + + + + 48 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 48 + 144 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 14 + 14 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 288 + 48 + 1 + 1 + + + + + + + + + + + + 288 + 48 + 1 + 1 + + + + + 288 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 288 + 48 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 14 + 14 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + + + + 1 + 288 + 14 + 14 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 288 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 288 + 1 + 1 + 5 + 5 + + + + + 288 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 288 + 14 + 14 + + + 288 + 1 + 1 + 5 + 5 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 7 + 7 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 72 + 288 + 1 + 1 + + + + + + + + + + + + 72 + 288 + 1 + 1 + + + + + 72 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + 72 + 288 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 1 + 1 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 288 + 72 + 1 + 1 + + + + + + + + + + + + 288 + 72 + 1 + 1 + + + + + 288 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 1 + 1 + + + 288 + 72 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 96 + 288 + 1 + 1 + + + + + + + + + + + + 96 + 288 + 1 + 1 + + + + + 96 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + 96 + 288 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + + 576 + 96 + 1 + 1 + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + + 144 + 576 + 1 + 1 + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + + 576 + 144 + 1 + 1 + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + + 96 + 576 + 1 + 1 + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + + 576 + 96 + 1 + 1 + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + + 144 + 576 + 1 + 1 + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + + 576 + 144 + 1 + 1 + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + + 96 + 576 + 1 + 1 + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + + 576 + 96 + 1 + 1 + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1024 + 576 + 1 + 1 + + + + + + + + + + + + 1024 + 576 + 1 + 1 + + + + + 1024 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1024 + 576 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1001 + 1024 + 1 + 1 + + + + + + + + + + + + 1001 + 1024 + 1 + 1 + + + + + 1001 + 1024 + 1 + 1 + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + 1001 + 1024 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 1 + 1001 + 1 + 1 + + + + + + + + + + + + 1 + 1001 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + + + + 1 + 1001 + 1 + 1 + + + 1 + 1001 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + + + + 2 + + + + + + + + + + 1 + 1001 + 1 + 1 + + + 2 + + + + + 1 + 1001 + + + + + + + + + + + 2 + + + + + + + + + + + 1 + 1001 + + + 2 + + + + + 1 + 1001 + + + + + + + + + + + 1 + 1001 + + + + + 1 + 1001 + + + + + + + + + + 1 + 1001 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_2/mypackage/__init__.py b/session_2/mypackage/__init__.py new file mode 100644 index 0000000..b4367c1 --- /dev/null +++ b/session_2/mypackage/__init__.py @@ -0,0 +1 @@ +from .mymodule import my_func diff --git a/session_2/mypackage/mymodule.py b/session_2/mypackage/mymodule.py new file mode 100644 index 0000000..fd88c78 --- /dev/null +++ b/session_2/mypackage/mymodule.py @@ -0,0 +1,6 @@ +def my_func(a, b): + return a + b + + +if __name__ == "__main__": + print(my_func(100, 200)) diff --git a/session_2/witi/__init__.py b/session_2/witi/__init__.py new file mode 100644 index 0000000..3d476b4 --- /dev/null +++ b/session_2/witi/__init__.py @@ -0,0 +1 @@ +from .witi import Witi diff --git a/session_2/witi/witi.py b/session_2/witi/witi.py new file mode 100644 index 0000000..be767e3 --- /dev/null +++ b/session_2/witi/witi.py @@ -0,0 +1,31 @@ +from openvino.runtime import Core +import cv2 +import numpy as np + + +class Witi: + """ + What Is This Image? A simple wrapper for image classification with Intel OpenVINO. + """ + + def __init__( + self, + model: str = "./model/v3-small_224_1.0_float.xml", + labels: str = "./model/imagenet_2012.txt", + ): + + self._ie = Core() + loaded_model = self._ie.read_model(model=model) + self._model = self._ie.compile_model(loaded_model, device_name="CPU") + self._output_layer = self._model.output(0) + with open(labels) as f: + _labels = f.read().splitlines() + self._labels = ["background"] + _labels + + def predict(self, filename: str) -> str: + image = cv2.cvtColor(cv2.imread(filename), code=cv2.COLOR_BGR2RGB) + input_image = cv2.resize(src=image, dsize=(224, 224)) + input_image = np.expand_dims(input_image, 0) + predictions = self._model(input_image)[self._output_layer] # type: ignore + pred_index = np.argmax(predictions) + return self._labels[pred_index] diff --git a/session_3/Session_3.ipynb b/session_3/Session_3.ipynb new file mode 100644 index 0000000..e99ad6a --- /dev/null +++ b/session_3/Session_3.ipynb @@ -0,0 +1,1279 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Session 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Types" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Binary operations: `bool`" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, World\n" + ] + } + ], + "source": [ + "print(\"Hello, World\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "a = True\n", + "b = False" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a and b" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a or b" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not a" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "not b" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a == b" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 < 2" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 >= 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numeric types: `int`, `float` and `Decimal`" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from decimal import Decimal\n", + "\n", + "a = Decimal(1)\n", + "print(type(a))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "a = 1.2345" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Collections: `list`, `dict`, `tuple`, `set`" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3]\n" + ] + } + ], + "source": [ + "l = [1,2,3]\n", + "print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['word', 1, 2, 3, 10, 10]\n" + ] + } + ], + "source": [ + "l = ['word'] + l\n", + "print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "d = {\n", + " \"one\": 1\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a': 1, 1: 'a', (1,): 'list'}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{\n", + " \"a\":1,\n", + " 1: \"a\",\n", + " (1,) : 'list'\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "a = (1,2,3,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1, 2, 3, 4}\n" + ] + } + ], + "source": [ + "s = set([1,2,3,4,1,2,3,4])\n", + "print(s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Strings: `str`" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "a = \"this is some text\"" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not here\n" + ] + } + ], + "source": [ + "my_word = 'Jose'\n", + "\n", + "if my_word in a:\n", + " print(f\"my word {my_word} is in the string 'a'\")\n", + "\n", + "else:\n", + " print(\"Not here\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'My number is : 1.23'" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 1.234567\n", + "f\"My number is : {a:.2f}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "global_var = 1\n", + "\n", + "def func(local_var):\n", + " return local_var" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func(global_var)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loops" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n", + "counting...\n" + ] + } + ], + "source": [ + "counter = 0\n", + "while(counter < 10):\n", + " print(\"counting...\")\n", + " counter += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "My item is 1\n", + "My item is 2\n", + "My item is 3\n", + "My item is 4\n", + "My item is 4\n", + "My item is 56\n" + ] + } + ], + "source": [ + "l = [1,2,3,4,4,56]\n", + "for item in l:\n", + " print(f\"My item is {item}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 4, 56]" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 4, 56]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[3:]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3, 4, 4]" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[1:-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4, 4, 56]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3]" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l[1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s is a fancy string\n", + "gnirts ycnaf a si sihT\n" + ] + } + ], + "source": [ + "a = \"This is a fancy string\"\n", + "\n", + "print(a[3:])\n", + "\n", + "print(a[::-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 4, 56]\n", + "[1, 3, 4]\n", + "Ti safnysrn\n" + ] + } + ], + "source": [ + "print(l)\n", + "print(l[0:5:2])\n", + "print(a[0::2])" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n" + ] + } + ], + "source": [ + "a = []\n", + "for i in range(10):\n", + " a.append(i)\n", + "\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "{1, 2, 3, 4, 6, 7, 8, 54}\n", + "{'hello': 0, 'my': 1, 'name': 2, 'is': 3, 'Jose': 4}\n", + "['1', '3', '5', '7', '9']\n" + ] + } + ], + "source": [ + "a = [i for i in range(10)]\n", + "print(a)\n", + "\n", + "b = {c for c in [1,2,3,4,1,2,3,4,1,2,3,4,54,6,7,8]}\n", + "print(b)\n", + "\n", + "words =['hello','my','name','is','Jose']\n", + "d = {k:i for i,k in enumerate(words)}\n", + "print(d)\n", + "\n", + "a = '0123456789'\n", + "odd = [i for i in a if int(i)%2 != 0]\n", + "print(odd)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "def func(a,b,c=0,d=0):\n", + " \"\"\"\n", + " This function returns the product of (a+c) * (b+d)\n", + " \"\"\"\n", + " return (a + c) * (b + d)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m This function returns the product of (a+c) * (b+d)\n", + "\u001b[0;31mFile:\u001b[0m /var/folders/7n/vf_8l1x10bn365f4bvdt0rjm0000gn/T/ipykernel_12087/942612519.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + } + ], + "source": [ + "func?" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "24\n", + "8\n", + "6\n", + "6\n" + ] + } + ], + "source": [ + "print(func(1,2))\n", + "print(func(1,2,3,4))\n", + "print(func(1,2,3))\n", + "print(func(1,2,d=4))\n", + "print(func(a=1,b=2,d=4))\n", + "# print(func(a=1,d=2)) # This line causes error" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 5]\n" + ] + } + ], + "source": [ + "a =1\n", + "\n", + "a += 1\n", + "\n", + "d = {'key': 0}\n", + "d['other_key'] = 1\n", + "\n", + "l = [1,2,3]\n", + "l.append(5)\n", + "print(l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pitfalls: Mutable types as default values" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "def func(key, value, d = {}):\n", + " d[key] = value\n", + " return d" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'key': 0}" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func('key',0)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'key': 0, 'other_key': 1}" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func('other_key', 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "def func(key, value, d = None):\n", + " d = d or {}\n", + "\n", + " d[key] = value\n", + " return d" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'second': 2}" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "func('first',1)\n", + "func('second',2) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classes" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [], + "source": [ + "class Fraction:\n", + " numerator: int\n", + " denominator: int\n", + "\n", + " def __init__(self, numerator, denominator):\n", + " self.numerator = numerator\n", + " self.denominator = denominator\n", + "\n", + " def __repr__(self):\n", + " return f\"Fraction(numerator={self.numerator},denominator={self.denominator})\"\n", + "\n", + " def __lt__(self, other: 'Fraction'):\n", + " s = self.numerator/self.denominator\n", + " o = other.numerator / other.denominator\n", + " return s < o\n", + "\n", + " # def __hash__(self):\n", + " # raise NotImplemented(\"This type is not hashable\")\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraction(numerator=1,denominator=2)\n", + "291969304\n", + "291969049\n", + "False\n", + "[Fraction(numerator=1,denominator=3), Fraction(numerator=1,denominator=2)]\n", + "False\n" + ] + } + ], + "source": [ + "f = Fraction(1,2)\n", + "f2 = Fraction(1,3)\n", + "print(f)\n", + "\n", + "print(hash(f))\n", + "print(hash(f2))\n", + "print(f == f2)\n", + "\n", + "print(sorted([f,f2]))\n", + "print(f < f2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dunder Methods" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hack: `dataclass`" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [], + "source": [ + "from dataclasses import dataclass\n", + "\n", + "@dataclass\n", + "class Fraction2:\n", + " numerator: int\n", + " denominator: int\n", + "\n", + " def __lt__(self, other):\n", + " s = self.numerator/self.denominator\n", + " o = other.numerator / other.denominator\n", + " return s < o" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraction2(numerator=1, denominator=2)\n", + "[Fraction2(numerator=1, denominator=3), Fraction2(numerator=1, denominator=2)]\n", + "[Fraction(numerator=1,denominator=3), Fraction2(numerator=1, denominator=3), Fraction(numerator=1,denominator=2), Fraction2(numerator=1, denominator=2)]\n" + ] + } + ], + "source": [ + "f3 = Fraction2(numerator=1, denominator=2)\n", + "f4 = Fraction2(numerator=1, denominator=3)\n", + "print(f3)\n", + "print(sorted([f3,f4]))\n", + "\n", + "print(sorted([f,f2,f3,f4]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Better Hack: `pydantic`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modules and the `import system`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from mypackage.mymodule import my_func" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intel's OpenVINO: A very quick intro\n", + "\n", + "OpenVINO is a great library to get started with Machine Learning enabled applications. Take a look at the official documentation at:\n", + "\n", + "https://docs.openvino.ai/latest/index.html\n", + "\n", + "and play around with Inte's Github repos:\n", + "\n", + "https://github.com/openvinotoolkit/openvino_notebooks\n", + "\n", + "And the Open Model Zoo:\n", + "\n", + "https://github.com/openvinotoolkit/open_model_zoo\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting matplotlib\n", + " Using cached matplotlib-3.6.1-cp310-cp310-macosx_11_0_arm64.whl (7.2 MB)\n", + "Collecting kiwisolver>=1.0.1\n", + " Using cached kiwisolver-1.4.4-cp310-cp310-macosx_11_0_arm64.whl (63 kB)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: numpy>=1.19 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (1.23.1)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (21.3)\n", + "Collecting contourpy>=1.0.1\n", + " Downloading contourpy-1.0.6-cp310-cp310-macosx_11_0_arm64.whl (225 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m225.9/225.9 kB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pillow>=6.2.0 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (9.3.0)\n", + "Collecting cycler>=0.10\n", + " Using cached cycler-0.11.0-py3-none-any.whl (6.4 kB)\n", + "Collecting fonttools>=4.22.0\n", + " Using cached fonttools-4.38.0-py3-none-any.whl (965 kB)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: six>=1.5 in /Users/chepe/.virtualenvs/hd-python/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Installing collected packages: kiwisolver, fonttools, cycler, contourpy, matplotlib\n", + "Successfully installed contourpy-1.0.6 cycler-0.11.0 fonttools-4.38.0 kiwisolver-1.4.4 matplotlib-3.6.1\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.2.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m22.3\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import Core\n", + "import cv2\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "ie = Core()\n", + "model = ie.read_model(model=\"./model/v3-small_224_1.0_float.xml\")\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")\n", + "\n", + "output_layer = compiled_model.output(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "]\n", + "outputs[\n", + "\n", + "]>" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compiled_model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The MobileNet model expects images in RGB format.\n", + "image = cv2.cvtColor(cv2.imread(filename=\"./assets/maybe_cat.jpg\"), code=cv2.COLOR_BGR2RGB)\n", + "\n", + "# Resize to MobileNet image shape.\n", + "input_image = cv2.resize(src=image, dsize=(224, 224))\n", + "\n", + "# Reshape to model input shape.\n", + "input_image = np.expand_dims(input_image, 0)\n", + "plt.imshow(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n02325366 wood rabbit, cottontail, cottontail rabbit\n" + ] + } + ], + "source": [ + "result_infer = compiled_model([input_image])[output_layer]\n", + "result_index = np.argmax(result_infer)\n", + "# Convert the inference result to a class name.\n", + "imagenet_classes = open(\"./model/imagenet_2012.txt\").read().splitlines()\n", + "\n", + "# The model description states that for this model, class 0 is a background.\n", + "# Therefore, a background must be added at the beginning of imagenet_classes.\n", + "imagenet_classes = ['background'] + imagenet_classes\n", + "\n", + "print(imagenet_classes[result_index])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What Is This Image?\n", + "Let's make a library with a simple interface for our program." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from witi import Witi" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "w = Witi()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'n02325366 wood rabbit, cottontail, cottontail rabbit'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w.predict(\"./assets/maybe_cat.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.8 ('hd-python')", + "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.10.8" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "2b9031acb0a45c02dc5ff3533df24ff50e427e72ecd9254d59def021522d4109" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session_3/assets/large_file.txt b/session_3/assets/large_file.txt new file mode 100644 index 0000000..c344d0a --- /dev/null +++ b/session_3/assets/large_file.txt @@ -0,0 +1,100 @@ +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 diff --git a/session_3/openvino_notebooks/001-hello-world/001-hello-world.ipynb b/session_3/openvino_notebooks/001-hello-world/001-hello-world.ipynb new file mode 100644 index 0000000..8d17b45 --- /dev/null +++ b/session_3/openvino_notebooks/001-hello-world/001-hello-world.ipynb @@ -0,0 +1,177 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "291dc37b", + "metadata": {}, + "source": [ + "# Hello Image Classification\n", + "\n", + "This basic introduction to OpenVINO™ shows how to do inference with an image classification model.\n", + "\n", + "A pre-trained [MobileNetV3 model](https://docs.openvino.ai/latest/omz_models_model_mobilenet_v3_small_1_0_224_tf.html) from [Open Model Zoo](https://github.com/openvinotoolkit/open_model_zoo/) is used in this tutorial. For more information about how OpenVINO IR models are created, refer to the [TensorFlow to OpenVINO](../101-tensorflow-to-openvino/101-tensorflow-to-openvino.ipynb) tutorial." + ] + }, + { + "cell_type": "markdown", + "id": "e4c8cbe5", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "41ee9436", + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from openvino.runtime import Core" + ] + }, + { + "cell_type": "markdown", + "id": "55e49ae7", + "metadata": {}, + "source": [ + "## Load the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e3c4d6fc", + "metadata": {}, + "outputs": [], + "source": [ + "ie = Core()\n", + "model = ie.read_model(model=\"model/v3-small_224_1.0_float.xml\")\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")\n", + "\n", + "output_layer = compiled_model.output(0)" + ] + }, + { + "cell_type": "markdown", + "id": "a19fc080", + "metadata": {}, + "source": [ + "## Load an Image" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "eca45b68", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# The MobileNet model expects images in RGB format.\n", + "image = cv2.cvtColor(cv2.imread(filename=\"data/coco.jpg\"), code=cv2.COLOR_BGR2RGB)\n", + "\n", + "# Resize to MobileNet image shape.\n", + "input_image = cv2.resize(src=image, dsize=(224, 224))\n", + "\n", + "# Reshape to model input shape.\n", + "input_image = np.expand_dims(input_image, 0)\n", + "plt.imshow(image);" + ] + }, + { + "cell_type": "markdown", + "id": "6be327b6", + "metadata": {}, + "source": [ + "## Do Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1ed78a71", + "metadata": {}, + "outputs": [], + "source": [ + "result_infer = compiled_model([input_image])[output_layer]\n", + "result_index = np.argmax(result_infer)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bf29578c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'n02099267 flat-coated retriever'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert the inference result to a class name.\n", + "imagenet_classes = open(\"utils/imagenet_2012.txt\").read().splitlines()\n", + "\n", + "# The model description states that for this model, class 0 is a background.\n", + "# Therefore, a background must be added at the beginning of imagenet_classes.\n", + "imagenet_classes = ['background'] + imagenet_classes\n", + "\n", + "imagenet_classes[result_index]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "285a5cbc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "cd5437b16fd5f67deabdf7e7132d444cc39310b7a33353e3b68dab8f7e829ac5" + }, + "kernelspec": { + "display_name": "Python 3", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/session_3/openvino_notebooks/001-hello-world/README.md b/session_3/openvino_notebooks/001-hello-world/README.md new file mode 100644 index 0000000..9162d80 --- /dev/null +++ b/session_3/openvino_notebooks/001-hello-world/README.md @@ -0,0 +1,15 @@ +# Introduction to OpenVINO™ + +[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/openvinotoolkit/openvino_notebooks/HEAD?filepath=notebooks%2F001-hello-world%2F001-hello-world.ipynb) + +![classification](https://user-images.githubusercontent.com/36741649/127172572-1cdab941-df5f-42e2-a367-2b334a3db6d8.jpg) + +This notebook shows how to do inference on an OpenVINO IR model. + +## Notebook Contents + +This notebook demonstrates usage of [MobileNet V3](https://github.com/openvinotoolkit/open_model_zoo/blob/master/models/public/mobilenet-v3-small-1.0-224-tf/README.md) from [Open Model Zoo](https://github.com/openvinotoolkit/open_model_zoo/) + +## Installation Instructions + +If you have not installed all required dependencies, follow the [Installation Guide](../../README.md). diff --git a/session_3/openvino_notebooks/001-hello-world/data/coco.jpg b/session_3/openvino_notebooks/001-hello-world/data/coco.jpg new file mode 100644 index 0000000..6edd187 Binary files /dev/null and b/session_3/openvino_notebooks/001-hello-world/data/coco.jpg differ diff --git a/session_3/openvino_notebooks/001-hello-world/model/v3-small_224_1.0_float.bin b/session_3/openvino_notebooks/001-hello-world/model/v3-small_224_1.0_float.bin new file mode 100644 index 0000000..9100605 Binary files /dev/null and b/session_3/openvino_notebooks/001-hello-world/model/v3-small_224_1.0_float.bin differ diff --git a/session_3/openvino_notebooks/001-hello-world/model/v3-small_224_1.0_float.xml b/session_3/openvino_notebooks/001-hello-world/model/v3-small_224_1.0_float.xml new file mode 100644 index 0000000..25028b4 --- /dev/null +++ b/session_3/openvino_notebooks/001-hello-world/model/v3-small_224_1.0_float.xml @@ -0,0 +1,9626 @@ + + + + + + + + + + + + + 1 + 224 + 224 + 3 + + + + + + + + + + + 4 + + + + + + + + + + 1 + 224 + 224 + 3 + + + 4 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 1 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 3 + 1 + 1 + + + + + + + + + + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 1 + 1 + + + + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 16 + 3 + 3 + 3 + + + + + + + + + + + + 16 + 3 + 3 + 3 + + + + + 16 + 3 + 3 + 3 + + + + + + + + + + + 1 + 3 + 224 + 224 + + + 16 + 3 + 3 + 3 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 112 + 112 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 112 + 112 + + + + + + + + + + 1 + 16 + 112 + 112 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 16 + 1 + 1 + 3 + 3 + + + + + + + + + + + + 16 + 1 + 1 + 3 + 3 + + + + + 16 + 1 + 1 + 3 + 3 + + + + + + + + + + + 1 + 16 + 112 + 112 + + + 16 + 1 + 1 + 3 + 3 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 56 + 56 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 8 + 16 + 1 + 1 + + + + + + + + + + + + 8 + 16 + 1 + 1 + + + + + 8 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + 8 + 16 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + + + + + + + + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + + + + 1 + 8 + 1 + 1 + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 16 + 8 + 1 + 1 + + + + + + + + + + + + 16 + 8 + 1 + 1 + + + + + 16 + 8 + 1 + 1 + + + + + + + + + + + 1 + 8 + 1 + 1 + + + 16 + 8 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 16 + 16 + 1 + 1 + + + + + + + + + + + + 16 + 16 + 1 + 1 + + + + + 16 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 16 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 72 + 16 + 1 + 1 + + + + + + + + + + + + 72 + 16 + 1 + 1 + + + + + 72 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 56 + 56 + + + 72 + 16 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 56 + 56 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + + + + 1 + 72 + 56 + 56 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 72 + 1 + 1 + 3 + 3 + + + + + + + + + + + + 72 + 1 + 1 + 3 + 3 + + + + + 72 + 1 + 1 + 3 + 3 + + + + + + + + + + + 1 + 72 + 56 + 56 + + + 72 + 1 + 1 + 3 + 3 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 28 + 28 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 28 + 28 + + + + + + + + + + 1 + 72 + 28 + 28 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 24 + 72 + 1 + 1 + + + + + + + + + + + + 24 + 72 + 1 + 1 + + + + + 24 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 28 + 28 + + + 24 + 72 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 88 + 24 + 1 + 1 + + + + + + + + + + + + 88 + 24 + 1 + 1 + + + + + 88 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 88 + 24 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 88 + 1 + 1 + 3 + 3 + + + + + + + + + + + + 88 + 1 + 1 + 3 + 3 + + + + + 88 + 1 + 1 + 3 + 3 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 88 + 1 + 1 + 3 + 3 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 1 + 1 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 24 + 88 + 1 + 1 + + + + + + + + + + + + 24 + 88 + 1 + 1 + + + + + 24 + 88 + 1 + 1 + + + + + + + + + + + 1 + 88 + 28 + 28 + + + 24 + 88 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 28 + 28 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + + 96 + 24 + 1 + 1 + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 28 + 28 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 28 + 28 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + + + + 1 + 96 + 28 + 28 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 96 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 96 + 1 + 1 + 5 + 5 + + + + + 96 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 96 + 28 + 28 + + + 96 + 1 + 1 + 5 + 5 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 14 + 14 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 24 + 96 + 1 + 1 + + + + + + + + + + + + 24 + 96 + 1 + 1 + + + + + 24 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + 24 + 96 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 1 + 1 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + + 96 + 24 + 1 + 1 + + + + + 96 + 24 + 1 + 1 + + + + + + + + + + + 1 + 24 + 1 + 1 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 40 + 96 + 1 + 1 + + + + + + + + + + + + 40 + 96 + 1 + 1 + + + + + 40 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 14 + 14 + + + 40 + 96 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + + 240 + 40 + 1 + 1 + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + + 64 + 240 + 1 + 1 + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + + 240 + 64 + 1 + 1 + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + + 40 + 240 + 1 + 1 + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + + 240 + 40 + 1 + 1 + + + + + 240 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + + 64 + 240 + 1 + 1 + + + + + 64 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + + 240 + 64 + 1 + 1 + + + + + 240 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + + 40 + 240 + 1 + 1 + + + + + 40 + 240 + 1 + 1 + + + + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 120 + 40 + 1 + 1 + + + + + + + + + + + + 120 + 40 + 1 + 1 + + + + + 120 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 14 + 14 + + + 120 + 40 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 120 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 120 + 1 + 1 + 5 + 5 + + + + + 120 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 120 + 1 + 1 + 5 + 5 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 32 + 120 + 1 + 1 + + + + + + + + + + + + 32 + 120 + 1 + 1 + + + + + 32 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + 32 + 120 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + + 1 + 32 + 1 + 1 + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 120 + 32 + 1 + 1 + + + + + + + + + + + + 120 + 32 + 1 + 1 + + + + + 120 + 32 + 1 + 1 + + + + + + + + + + + 1 + 32 + 1 + 1 + + + 120 + 32 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 48 + 120 + 1 + 1 + + + + + + + + + + + + 48 + 120 + 1 + 1 + + + + + 48 + 120 + 1 + 1 + + + + + + + + + + + 1 + 120 + 14 + 14 + + + 48 + 120 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 144 + 48 + 1 + 1 + + + + + + + + + + + + 144 + 48 + 1 + 1 + + + + + 144 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 144 + 48 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 144 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 144 + 1 + 1 + 5 + 5 + + + + + 144 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 144 + 1 + 1 + 5 + 5 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 40 + 144 + 1 + 1 + + + + + + + + + + + + 40 + 144 + 1 + 1 + + + + + 40 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 40 + 144 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 1 + 1 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 144 + 40 + 1 + 1 + + + + + + + + + + + + 144 + 40 + 1 + 1 + + + + + 144 + 40 + 1 + 1 + + + + + + + + + + + 1 + 40 + 1 + 1 + + + 144 + 40 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 48 + 144 + 1 + 1 + + + + + + + + + + + + 48 + 144 + 1 + 1 + + + + + 48 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 14 + 14 + + + 48 + 144 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 14 + 14 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 288 + 48 + 1 + 1 + + + + + + + + + + + + 288 + 48 + 1 + 1 + + + + + 288 + 48 + 1 + 1 + + + + + + + + + + + 1 + 48 + 14 + 14 + + + 288 + 48 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 14 + 14 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + + + + 1 + 288 + 14 + 14 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 288 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 288 + 1 + 1 + 5 + 5 + + + + + 288 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 288 + 14 + 14 + + + 288 + 1 + 1 + 5 + 5 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 7 + 7 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 72 + 288 + 1 + 1 + + + + + + + + + + + + 72 + 288 + 1 + 1 + + + + + 72 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + 72 + 288 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 1 + 1 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 288 + 72 + 1 + 1 + + + + + + + + + + + + 288 + 72 + 1 + 1 + + + + + 288 + 72 + 1 + 1 + + + + + + + + + + + 1 + 72 + 1 + 1 + + + 288 + 72 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 96 + 288 + 1 + 1 + + + + + + + + + + + + 96 + 288 + 1 + 1 + + + + + 96 + 288 + 1 + 1 + + + + + + + + + + + 1 + 288 + 7 + 7 + + + 96 + 288 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + + 576 + 96 + 1 + 1 + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + + 144 + 576 + 1 + 1 + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + + 576 + 144 + 1 + 1 + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + + 96 + 576 + 1 + 1 + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + + 576 + 96 + 1 + 1 + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + + 144 + 576 + 1 + 1 + + + + + 144 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + + 576 + 144 + 1 + 1 + + + + + 576 + 144 + 1 + 1 + + + + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + + 96 + 576 + 1 + 1 + + + + + 96 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + + 576 + 96 + 1 + 1 + + + + + 576 + 96 + 1 + 1 + + + + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1024 + 576 + 1 + 1 + + + + + + + + + + + + 1024 + 576 + 1 + 1 + + + + + 1024 + 576 + 1 + 1 + + + + + + + + + + + 1 + 576 + 1 + 1 + + + 1024 + 576 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1001 + 1024 + 1 + 1 + + + + + + + + + + + + 1001 + 1024 + 1 + 1 + + + + + 1001 + 1024 + 1 + 1 + + + + + + + + + + + 1 + 1024 + 1 + 1 + + + 1001 + 1024 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 1 + 1001 + 1 + 1 + + + + + + + + + + + + 1 + 1001 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + + + + 1 + 1001 + 1 + 1 + + + 1 + 1001 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + + + + 2 + + + + + + + + + + 1 + 1001 + 1 + 1 + + + 2 + + + + + 1 + 1001 + + + + + + + + + + + 2 + + + + + + + + + + + 1 + 1001 + + + 2 + + + + + 1 + 1001 + + + + + + + + + + + 1 + 1001 + + + + + 1 + 1001 + + + + + + + + + + 1 + 1001 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_3/openvino_notebooks/001-hello-world/utils/imagenet_2012.txt b/session_3/openvino_notebooks/001-hello-world/utils/imagenet_2012.txt new file mode 100644 index 0000000..a9e8c7f --- /dev/null +++ b/session_3/openvino_notebooks/001-hello-world/utils/imagenet_2012.txt @@ -0,0 +1,1000 @@ +n01440764 tench, Tinca tinca +n01443537 goldfish, Carassius auratus +n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias +n01491361 tiger shark, Galeocerdo cuvieri +n01494475 hammerhead, hammerhead shark +n01496331 electric ray, crampfish, numbfish, torpedo +n01498041 stingray +n01514668 cock +n01514859 hen +n01518878 ostrich, Struthio camelus +n01530575 brambling, Fringilla montifringilla +n01531178 goldfinch, Carduelis carduelis +n01532829 house finch, linnet, Carpodacus mexicanus +n01534433 junco, snowbird +n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea +n01558993 robin, American robin, Turdus migratorius +n01560419 bulbul +n01580077 jay +n01582220 magpie +n01592084 chickadee +n01601694 water ouzel, dipper +n01608432 kite +n01614925 bald eagle, American eagle, Haliaeetus leucocephalus +n01616318 vulture +n01622779 great grey owl, great gray owl, Strix nebulosa +n01629819 European fire salamander, Salamandra salamandra +n01630670 common newt, Triturus vulgaris +n01631663 eft +n01632458 spotted salamander, Ambystoma maculatum +n01632777 axolotl, mud puppy, Ambystoma mexicanum +n01641577 bullfrog, Rana catesbeiana +n01644373 tree frog, tree-frog +n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui +n01664065 loggerhead, loggerhead turtle, Caretta caretta +n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea +n01667114 mud turtle +n01667778 terrapin +n01669191 box turtle, box tortoise +n01675722 banded gecko +n01677366 common iguana, iguana, Iguana iguana +n01682714 American chameleon, anole, Anolis carolinensis +n01685808 whiptail, whiptail lizard +n01687978 agama +n01688243 frilled lizard, Chlamydosaurus kingi +n01689811 alligator lizard +n01692333 Gila monster, Heloderma suspectum +n01693334 green lizard, Lacerta viridis +n01694178 African chameleon, Chamaeleo chamaeleon +n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis +n01697457 African crocodile, Nile crocodile, Crocodylus niloticus +n01698640 American alligator, Alligator mississipiensis +n01704323 triceratops +n01728572 thunder snake, worm snake, Carphophis amoenus +n01728920 ringneck snake, ring-necked snake, ring snake +n01729322 hognose snake, puff adder, sand viper +n01729977 green snake, grass snake +n01734418 king snake, kingsnake +n01735189 garter snake, grass snake +n01737021 water snake +n01739381 vine snake +n01740131 night snake, Hypsiglena torquata +n01742172 boa constrictor, Constrictor constrictor +n01744401 rock python, rock snake, Python sebae +n01748264 Indian cobra, Naja naja +n01749939 green mamba +n01751748 sea snake +n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus +n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus +n01756291 sidewinder, horned rattlesnake, Crotalus cerastes +n01768244 trilobite +n01770081 harvestman, daddy longlegs, Phalangium opilio +n01770393 scorpion +n01773157 black and gold garden spider, Argiope aurantia +n01773549 barn spider, Araneus cavaticus +n01773797 garden spider, Aranea diademata +n01774384 black widow, Latrodectus mactans +n01774750 tarantula +n01775062 wolf spider, hunting spider +n01776313 tick +n01784675 centipede +n01795545 black grouse +n01796340 ptarmigan +n01797886 ruffed grouse, partridge, Bonasa umbellus +n01798484 prairie chicken, prairie grouse, prairie fowl +n01806143 peacock +n01806567 quail +n01807496 partridge +n01817953 African grey, African gray, Psittacus erithacus +n01818515 macaw +n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita +n01820546 lorikeet +n01824575 coucal +n01828970 bee eater +n01829413 hornbill +n01833805 hummingbird +n01843065 jacamar +n01843383 toucan +n01847000 drake +n01855032 red-breasted merganser, Mergus serrator +n01855672 goose +n01860187 black swan, Cygnus atratus +n01871265 tusker +n01872401 echidna, spiny anteater, anteater +n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus +n01877812 wallaby, brush kangaroo +n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus +n01883070 wombat +n01910747 jellyfish +n01914609 sea anemone, anemone +n01917289 brain coral +n01924916 flatworm, platyhelminth +n01930112 nematode, nematode worm, roundworm +n01943899 conch +n01944390 snail +n01945685 slug +n01950731 sea slug, nudibranch +n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore +n01968897 chambered nautilus, pearly nautilus, nautilus +n01978287 Dungeness crab, Cancer magister +n01978455 rock crab, Cancer irroratus +n01980166 fiddler crab +n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica +n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus +n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish +n01985128 crayfish, crawfish, crawdad, crawdaddy +n01986214 hermit crab +n01990800 isopod +n02002556 white stork, Ciconia ciconia +n02002724 black stork, Ciconia nigra +n02006656 spoonbill +n02007558 flamingo +n02009229 little blue heron, Egretta caerulea +n02009912 American egret, great white heron, Egretta albus +n02011460 bittern +n02012849 crane +n02013706 limpkin, Aramus pictus +n02017213 European gallinule, Porphyrio porphyrio +n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana +n02018795 bustard +n02025239 ruddy turnstone, Arenaria interpres +n02027492 red-backed sandpiper, dunlin, Erolia alpina +n02028035 redshank, Tringa totanus +n02033041 dowitcher +n02037110 oystercatcher, oyster catcher +n02051845 pelican +n02056570 king penguin, Aptenodytes patagonica +n02058221 albatross, mollymawk +n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus +n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca +n02074367 dugong, Dugong dugon +n02077923 sea lion +n02085620 Chihuahua +n02085782 Japanese spaniel +n02085936 Maltese dog, Maltese terrier, Maltese +n02086079 Pekinese, Pekingese, Peke +n02086240 Shih-Tzu +n02086646 Blenheim spaniel +n02086910 papillon +n02087046 toy terrier +n02087394 Rhodesian ridgeback +n02088094 Afghan hound, Afghan +n02088238 basset, basset hound +n02088364 beagle +n02088466 bloodhound, sleuthhound +n02088632 bluetick +n02089078 black-and-tan coonhound +n02089867 Walker hound, Walker foxhound +n02089973 English foxhound +n02090379 redbone +n02090622 borzoi, Russian wolfhound +n02090721 Irish wolfhound +n02091032 Italian greyhound +n02091134 whippet +n02091244 Ibizan hound, Ibizan Podenco +n02091467 Norwegian elkhound, elkhound +n02091635 otterhound, otter hound +n02091831 Saluki, gazelle hound +n02092002 Scottish deerhound, deerhound +n02092339 Weimaraner +n02093256 Staffordshire bullterrier, Staffordshire bull terrier +n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier +n02093647 Bedlington terrier +n02093754 Border terrier +n02093859 Kerry blue terrier +n02093991 Irish terrier +n02094114 Norfolk terrier +n02094258 Norwich terrier +n02094433 Yorkshire terrier +n02095314 wire-haired fox terrier +n02095570 Lakeland terrier +n02095889 Sealyham terrier, Sealyham +n02096051 Airedale, Airedale terrier +n02096177 cairn, cairn terrier +n02096294 Australian terrier +n02096437 Dandie Dinmont, Dandie Dinmont terrier +n02096585 Boston bull, Boston terrier +n02097047 miniature schnauzer +n02097130 giant schnauzer +n02097209 standard schnauzer +n02097298 Scotch terrier, Scottish terrier, Scottie +n02097474 Tibetan terrier, chrysanthemum dog +n02097658 silky terrier, Sydney silky +n02098105 soft-coated wheaten terrier +n02098286 West Highland white terrier +n02098413 Lhasa, Lhasa apso +n02099267 flat-coated retriever +n02099429 curly-coated retriever +n02099601 golden retriever +n02099712 Labrador retriever +n02099849 Chesapeake Bay retriever +n02100236 German short-haired pointer +n02100583 vizsla, Hungarian pointer +n02100735 English setter +n02100877 Irish setter, red setter +n02101006 Gordon setter +n02101388 Brittany spaniel +n02101556 clumber, clumber spaniel +n02102040 English springer, English springer spaniel +n02102177 Welsh springer spaniel +n02102318 cocker spaniel, English cocker spaniel, cocker +n02102480 Sussex spaniel +n02102973 Irish water spaniel +n02104029 kuvasz +n02104365 schipperke +n02105056 groenendael +n02105162 malinois +n02105251 briard +n02105412 kelpie +n02105505 komondor +n02105641 Old English sheepdog, bobtail +n02105855 Shetland sheepdog, Shetland sheep dog, Shetland +n02106030 collie +n02106166 Border collie +n02106382 Bouvier des Flandres, Bouviers des Flandres +n02106550 Rottweiler +n02106662 German shepherd, German shepherd dog, German police dog, alsatian +n02107142 Doberman, Doberman pinscher +n02107312 miniature pinscher +n02107574 Greater Swiss Mountain dog +n02107683 Bernese mountain dog +n02107908 Appenzeller +n02108000 EntleBucher +n02108089 boxer +n02108422 bull mastiff +n02108551 Tibetan mastiff +n02108915 French bulldog +n02109047 Great Dane +n02109525 Saint Bernard, St Bernard +n02109961 Eskimo dog, husky +n02110063 malamute, malemute, Alaskan malamute +n02110185 Siberian husky +n02110341 dalmatian, coach dog, carriage dog +n02110627 affenpinscher, monkey pinscher, monkey dog +n02110806 basenji +n02110958 pug, pug-dog +n02111129 Leonberg +n02111277 Newfoundland, Newfoundland dog +n02111500 Great Pyrenees +n02111889 Samoyed, Samoyede +n02112018 Pomeranian +n02112137 chow, chow chow +n02112350 keeshond +n02112706 Brabancon griffon +n02113023 Pembroke, Pembroke Welsh corgi +n02113186 Cardigan, Cardigan Welsh corgi +n02113624 toy poodle +n02113712 miniature poodle +n02113799 standard poodle +n02113978 Mexican hairless +n02114367 timber wolf, grey wolf, gray wolf, Canis lupus +n02114548 white wolf, Arctic wolf, Canis lupus tundrarum +n02114712 red wolf, maned wolf, Canis rufus, Canis niger +n02114855 coyote, prairie wolf, brush wolf, Canis latrans +n02115641 dingo, warrigal, warragal, Canis dingo +n02115913 dhole, Cuon alpinus +n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus +n02117135 hyena, hyaena +n02119022 red fox, Vulpes vulpes +n02119789 kit fox, Vulpes macrotis +n02120079 Arctic fox, white fox, Alopex lagopus +n02120505 grey fox, gray fox, Urocyon cinereoargenteus +n02123045 tabby, tabby cat +n02123159 tiger cat +n02123394 Persian cat +n02123597 Siamese cat, Siamese +n02124075 Egyptian cat +n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor +n02127052 lynx, catamount +n02128385 leopard, Panthera pardus +n02128757 snow leopard, ounce, Panthera uncia +n02128925 jaguar, panther, Panthera onca, Felis onca +n02129165 lion, king of beasts, Panthera leo +n02129604 tiger, Panthera tigris +n02130308 cheetah, chetah, Acinonyx jubatus +n02132136 brown bear, bruin, Ursus arctos +n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus +n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus +n02134418 sloth bear, Melursus ursinus, Ursus ursinus +n02137549 mongoose +n02138441 meerkat, mierkat +n02165105 tiger beetle +n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle +n02167151 ground beetle, carabid beetle +n02168699 long-horned beetle, longicorn, longicorn beetle +n02169497 leaf beetle, chrysomelid +n02172182 dung beetle +n02174001 rhinoceros beetle +n02177972 weevil +n02190166 fly +n02206856 bee +n02219486 ant, emmet, pismire +n02226429 grasshopper, hopper +n02229544 cricket +n02231487 walking stick, walkingstick, stick insect +n02233338 cockroach, roach +n02236044 mantis, mantid +n02256656 cicada, cicala +n02259212 leafhopper +n02264363 lacewing, lacewing fly +n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk +n02268853 damselfly +n02276258 admiral +n02277742 ringlet, ringlet butterfly +n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus +n02280649 cabbage butterfly +n02281406 sulphur butterfly, sulfur butterfly +n02281787 lycaenid, lycaenid butterfly +n02317335 starfish, sea star +n02319095 sea urchin +n02321529 sea cucumber, holothurian +n02325366 wood rabbit, cottontail, cottontail rabbit +n02326432 hare +n02328150 Angora, Angora rabbit +n02342885 hamster +n02346627 porcupine, hedgehog +n02356798 fox squirrel, eastern fox squirrel, Sciurus niger +n02361337 marmot +n02363005 beaver +n02364673 guinea pig, Cavia cobaya +n02389026 sorrel +n02391049 zebra +n02395406 hog, pig, grunter, squealer, Sus scrofa +n02396427 wild boar, boar, Sus scrofa +n02397096 warthog +n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius +n02403003 ox +n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis +n02410509 bison +n02412080 ram, tup +n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis +n02417914 ibex, Capra ibex +n02422106 hartebeest +n02422699 impala, Aepyceros melampus +n02423022 gazelle +n02437312 Arabian camel, dromedary, Camelus dromedarius +n02437616 llama +n02441942 weasel +n02442845 mink +n02443114 polecat, fitch, foulmart, foumart, Mustela putorius +n02443484 black-footed ferret, ferret, Mustela nigripes +n02444819 otter +n02445715 skunk, polecat, wood pussy +n02447366 badger +n02454379 armadillo +n02457408 three-toed sloth, ai, Bradypus tridactylus +n02480495 orangutan, orang, orangutang, Pongo pygmaeus +n02480855 gorilla, Gorilla gorilla +n02481823 chimpanzee, chimp, Pan troglodytes +n02483362 gibbon, Hylobates lar +n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus +n02484975 guenon, guenon monkey +n02486261 patas, hussar monkey, Erythrocebus patas +n02486410 baboon +n02487347 macaque +n02488291 langur +n02488702 colobus, colobus monkey +n02489166 proboscis monkey, Nasalis larvatus +n02490219 marmoset +n02492035 capuchin, ringtail, Cebus capucinus +n02492660 howler monkey, howler +n02493509 titi, titi monkey +n02493793 spider monkey, Ateles geoffroyi +n02494079 squirrel monkey, Saimiri sciureus +n02497673 Madagascar cat, ring-tailed lemur, Lemur catta +n02500267 indri, indris, Indri indri, Indri brevicaudatus +n02504013 Indian elephant, Elephas maximus +n02504458 African elephant, Loxodonta africana +n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens +n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca +n02514041 barracouta, snoek +n02526121 eel +n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch +n02606052 rock beauty, Holocanthus tricolor +n02607072 anemone fish +n02640242 sturgeon +n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus +n02643566 lionfish +n02655020 puffer, pufferfish, blowfish, globefish +n02666196 abacus +n02667093 abaya +n02669723 academic gown, academic robe, judge's robe +n02672831 accordion, piano accordion, squeeze box +n02676566 acoustic guitar +n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier +n02690373 airliner +n02692877 airship, dirigible +n02699494 altar +n02701002 ambulance +n02704792 amphibian, amphibious vehicle +n02708093 analog clock +n02727426 apiary, bee house +n02730930 apron +n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin +n02749479 assault rifle, assault gun +n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack +n02776631 bakery, bakeshop, bakehouse +n02777292 balance beam, beam +n02782093 balloon +n02783161 ballpoint, ballpoint pen, ballpen, Biro +n02786058 Band Aid +n02787622 banjo +n02788148 bannister, banister, balustrade, balusters, handrail +n02790996 barbell +n02791124 barber chair +n02791270 barbershop +n02793495 barn +n02794156 barometer +n02795169 barrel, cask +n02797295 barrow, garden cart, lawn cart, wheelbarrow +n02799071 baseball +n02802426 basketball +n02804414 bassinet +n02804610 bassoon +n02807133 bathing cap, swimming cap +n02808304 bath towel +n02808440 bathtub, bathing tub, bath, tub +n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon +n02814860 beacon, lighthouse, beacon light, pharos +n02815834 beaker +n02817516 bearskin, busby, shako +n02823428 beer bottle +n02823750 beer glass +n02825657 bell cote, bell cot +n02834397 bib +n02835271 bicycle-built-for-two, tandem bicycle, tandem +n02837789 bikini, two-piece +n02840245 binder, ring-binder +n02841315 binoculars, field glasses, opera glasses +n02843684 birdhouse +n02859443 boathouse +n02860847 bobsled, bobsleigh, bob +n02865351 bolo tie, bolo, bola tie, bola +n02869837 bonnet, poke bonnet +n02870880 bookcase +n02871525 bookshop, bookstore, bookstall +n02877765 bottlecap +n02879718 bow +n02883205 bow tie, bow-tie, bowtie +n02892201 brass, memorial tablet, plaque +n02892767 brassiere, bra, bandeau +n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty +n02895154 breastplate, aegis, egis +n02906734 broom +n02909870 bucket, pail +n02910353 buckle +n02916936 bulletproof vest +n02917067 bullet train, bullet +n02927161 butcher shop, meat market +n02930766 cab, hack, taxi, taxicab +n02939185 caldron, cauldron +n02948072 candle, taper, wax light +n02950826 cannon +n02951358 canoe +n02951585 can opener, tin opener +n02963159 cardigan +n02965783 car mirror +n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig +n02966687 carpenter's kit, tool kit +n02971356 carton +n02974003 car wheel +n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM +n02978881 cassette +n02979186 cassette player +n02980441 castle +n02981792 catamaran +n02988304 CD player +n02992211 cello, violoncello +n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone +n02999410 chain +n03000134 chainlink fence +n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour +n03000684 chain saw, chainsaw +n03014705 chest +n03016953 chiffonier, commode +n03017168 chime, bell, gong +n03018349 china cabinet, china closet +n03026506 Christmas stocking +n03028079 church, church building +n03032252 cinema, movie theater, movie theatre, movie house, picture palace +n03041632 cleaver, meat cleaver, chopper +n03042490 cliff dwelling +n03045698 cloak +n03047690 clog, geta, patten, sabot +n03062245 cocktail shaker +n03063599 coffee mug +n03063689 coffeepot +n03065424 coil, spiral, volute, whorl, helix +n03075370 combination lock +n03085013 computer keyboard, keypad +n03089624 confectionery, confectionary, candy store +n03095699 container ship, containership, container vessel +n03100240 convertible +n03109150 corkscrew, bottle screw +n03110669 cornet, horn, trumpet, trump +n03124043 cowboy boot +n03124170 cowboy hat, ten-gallon hat +n03125729 cradle +n03126707 crane +n03127747 crash helmet +n03127925 crate +n03131574 crib, cot +n03133878 Crock Pot +n03134739 croquet ball +n03141823 crutch +n03146219 cuirass +n03160309 dam, dike, dyke +n03179701 desk +n03180011 desktop computer +n03187595 dial telephone, dial phone +n03188531 diaper, nappy, napkin +n03196217 digital clock +n03197337 digital watch +n03201208 dining table, board +n03207743 dishrag, dishcloth +n03207941 dishwasher, dish washer, dishwashing machine +n03208938 disk brake, disc brake +n03216828 dock, dockage, docking facility +n03218198 dogsled, dog sled, dog sleigh +n03220513 dome +n03223299 doormat, welcome mat +n03240683 drilling platform, offshore rig +n03249569 drum, membranophone, tympan +n03250847 drumstick +n03255030 dumbbell +n03259280 Dutch oven +n03271574 electric fan, blower +n03272010 electric guitar +n03272562 electric locomotive +n03290653 entertainment center +n03291819 envelope +n03297495 espresso maker +n03314780 face powder +n03325584 feather boa, boa +n03337140 file, file cabinet, filing cabinet +n03344393 fireboat +n03345487 fire engine, fire truck +n03347037 fire screen, fireguard +n03355925 flagpole, flagstaff +n03372029 flute, transverse flute +n03376595 folding chair +n03379051 football helmet +n03384352 forklift +n03388043 fountain +n03388183 fountain pen +n03388549 four-poster +n03393912 freight car +n03394916 French horn, horn +n03400231 frying pan, frypan, skillet +n03404251 fur coat +n03417042 garbage truck, dustcart +n03424325 gasmask, respirator, gas helmet +n03425413 gas pump, gasoline pump, petrol pump, island dispenser +n03443371 goblet +n03444034 go-kart +n03445777 golf ball +n03445924 golfcart, golf cart +n03447447 gondola +n03447721 gong, tam-tam +n03450230 gown +n03452741 grand piano, grand +n03457902 greenhouse, nursery, glasshouse +n03459775 grille, radiator grille +n03461385 grocery store, grocery, food market, market +n03467068 guillotine +n03476684 hair slide +n03476991 hair spray +n03478589 half track +n03481172 hammer +n03482405 hamper +n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier +n03485407 hand-held computer, hand-held microcomputer +n03485794 handkerchief, hankie, hanky, hankey +n03492542 hard disc, hard disk, fixed disk +n03494278 harmonica, mouth organ, harp, mouth harp +n03495258 harp +n03496892 harvester, reaper +n03498962 hatchet +n03527444 holster +n03529860 home theater, home theatre +n03530642 honeycomb +n03532672 hook, claw +n03534580 hoopskirt, crinoline +n03535780 horizontal bar, high bar +n03538406 horse cart, horse-cart +n03544143 hourglass +n03584254 iPod +n03584829 iron, smoothing iron +n03590841 jack-o'-lantern +n03594734 jean, blue jean, denim +n03594945 jeep, landrover +n03595614 jersey, T-shirt, tee shirt +n03598930 jigsaw puzzle +n03599486 jinrikisha, ricksha, rickshaw +n03602883 joystick +n03617480 kimono +n03623198 knee pad +n03627232 knot +n03630383 lab coat, laboratory coat +n03633091 ladle +n03637318 lampshade, lamp shade +n03642806 laptop, laptop computer +n03649909 lawn mower, mower +n03657121 lens cap, lens cover +n03658185 letter opener, paper knife, paperknife +n03661043 library +n03662601 lifeboat +n03666591 lighter, light, igniter, ignitor +n03670208 limousine, limo +n03673027 liner, ocean liner +n03676483 lipstick, lip rouge +n03680355 Loafer +n03690938 lotion +n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system +n03692522 loupe, jeweler's loupe +n03697007 lumbermill, sawmill +n03706229 magnetic compass +n03709823 mailbag, postbag +n03710193 mailbox, letter box +n03710637 maillot +n03710721 maillot, tank suit +n03717622 manhole cover +n03720891 maraca +n03721384 marimba, xylophone +n03724870 mask +n03729826 matchstick +n03733131 maypole +n03733281 maze, labyrinth +n03733805 measuring cup +n03742115 medicine chest, medicine cabinet +n03743016 megalith, megalithic structure +n03759954 microphone, mike +n03761084 microwave, microwave oven +n03763968 military uniform +n03764736 milk can +n03769881 minibus +n03770439 miniskirt, mini +n03770679 minivan +n03773504 missile +n03775071 mitten +n03775546 mixing bowl +n03776460 mobile home, manufactured home +n03777568 Model T +n03777754 modem +n03781244 monastery +n03782006 monitor +n03785016 moped +n03786901 mortar +n03787032 mortarboard +n03788195 mosque +n03788365 mosquito net +n03791053 motor scooter, scooter +n03792782 mountain bike, all-terrain bike, off-roader +n03792972 mountain tent +n03793489 mouse, computer mouse +n03794056 mousetrap +n03796401 moving van +n03803284 muzzle +n03804744 nail +n03814639 neck brace +n03814906 necklace +n03825788 nipple +n03832673 notebook, notebook computer +n03837869 obelisk +n03838899 oboe, hautboy, hautbois +n03840681 ocarina, sweet potato +n03841143 odometer, hodometer, mileometer, milometer +n03843555 oil filter +n03854065 organ, pipe organ +n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO +n03866082 overskirt +n03868242 oxcart +n03868863 oxygen mask +n03871628 packet +n03873416 paddle, boat paddle +n03874293 paddlewheel, paddle wheel +n03874599 padlock +n03876231 paintbrush +n03877472 pajama, pyjama, pj's, jammies +n03877845 palace +n03884397 panpipe, pandean pipe, syrinx +n03887697 paper towel +n03888257 parachute, chute +n03888605 parallel bars, bars +n03891251 park bench +n03891332 parking meter +n03895866 passenger car, coach, carriage +n03899768 patio, terrace +n03902125 pay-phone, pay-station +n03903868 pedestal, plinth, footstall +n03908618 pencil box, pencil case +n03908714 pencil sharpener +n03916031 perfume, essence +n03920288 Petri dish +n03924679 photocopier +n03929660 pick, plectrum, plectron +n03929855 pickelhaube +n03930313 picket fence, paling +n03930630 pickup, pickup truck +n03933933 pier +n03935335 piggy bank, penny bank +n03937543 pill bottle +n03938244 pillow +n03942813 ping-pong ball +n03944341 pinwheel +n03947888 pirate, pirate ship +n03950228 pitcher, ewer +n03954731 plane, carpenter's plane, woodworking plane +n03956157 planetarium +n03958227 plastic bag +n03961711 plate rack +n03967562 plow, plough +n03970156 plunger, plumber's helper +n03976467 Polaroid camera, Polaroid Land camera +n03976657 pole +n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria +n03980874 poncho +n03982430 pool table, billiard table, snooker table +n03983396 pop bottle, soda bottle +n03991062 pot, flowerpot +n03992509 potter's wheel +n03995372 power drill +n03998194 prayer rug, prayer mat +n04004767 printer +n04005630 prison, prison house +n04008634 projectile, missile +n04009552 projector +n04019541 puck, hockey puck +n04023962 punching bag, punch bag, punching ball, punchball +n04026417 purse +n04033901 quill, quill pen +n04033995 quilt, comforter, comfort, puff +n04037443 racer, race car, racing car +n04039381 racket, racquet +n04040759 radiator +n04041544 radio, wireless +n04044716 radio telescope, radio reflector +n04049303 rain barrel +n04065272 recreational vehicle, RV, R.V. +n04067472 reel +n04069434 reflex camera +n04070727 refrigerator, icebox +n04074963 remote control, remote +n04081281 restaurant, eating house, eating place, eatery +n04086273 revolver, six-gun, six-shooter +n04090263 rifle +n04099969 rocking chair, rocker +n04111531 rotisserie +n04116512 rubber eraser, rubber, pencil eraser +n04118538 rugby ball +n04118776 rule, ruler +n04120489 running shoe +n04125021 safe +n04127249 safety pin +n04131690 saltshaker, salt shaker +n04133789 sandal +n04136333 sarong +n04141076 sax, saxophone +n04141327 scabbard +n04141975 scale, weighing machine +n04146614 school bus +n04147183 schooner +n04149813 scoreboard +n04152593 screen, CRT screen +n04153751 screw +n04154565 screwdriver +n04162706 seat belt, seatbelt +n04179913 sewing machine +n04192698 shield, buckler +n04200800 shoe shop, shoe-shop, shoe store +n04201297 shoji +n04204238 shopping basket +n04204347 shopping cart +n04208210 shovel +n04209133 shower cap +n04209239 shower curtain +n04228054 ski +n04229816 ski mask +n04235860 sleeping bag +n04238763 slide rule, slipstick +n04239074 sliding door +n04243546 slot, one-armed bandit +n04251144 snorkel +n04252077 snowmobile +n04252225 snowplow, snowplough +n04254120 soap dispenser +n04254680 soccer ball +n04254777 sock +n04258138 solar dish, solar collector, solar furnace +n04259630 sombrero +n04263257 soup bowl +n04264628 space bar +n04265275 space heater +n04266014 space shuttle +n04270147 spatula +n04273569 speedboat +n04275548 spider web, spider's web +n04277352 spindle +n04285008 sports car, sport car +n04286575 spotlight, spot +n04296562 stage +n04310018 steam locomotive +n04311004 steel arch bridge +n04311174 steel drum +n04317175 stethoscope +n04325704 stole +n04326547 stone wall +n04328186 stopwatch, stop watch +n04330267 stove +n04332243 strainer +n04335435 streetcar, tram, tramcar, trolley, trolley car +n04336792 stretcher +n04344873 studio couch, day bed +n04346328 stupa, tope +n04347754 submarine, pigboat, sub, U-boat +n04350905 suit, suit of clothes +n04355338 sundial +n04355933 sunglass +n04356056 sunglasses, dark glasses, shades +n04357314 sunscreen, sunblock, sun blocker +n04366367 suspension bridge +n04367480 swab, swob, mop +n04370456 sweatshirt +n04371430 swimming trunks, bathing trunks +n04371774 swing +n04372370 switch, electric switch, electrical switch +n04376876 syringe +n04380533 table lamp +n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle +n04392985 tape player +n04398044 teapot +n04399382 teddy, teddy bear +n04404412 television, television system +n04409515 tennis ball +n04417672 thatch, thatched roof +n04418357 theater curtain, theatre curtain +n04423845 thimble +n04428191 thresher, thrasher, threshing machine +n04429376 throne +n04435653 tile roof +n04442312 toaster +n04443257 tobacco shop, tobacconist shop, tobacconist +n04447861 toilet seat +n04456115 torch +n04458633 totem pole +n04461696 tow truck, tow car, wrecker +n04462240 toyshop +n04465501 tractor +n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi +n04476259 tray +n04479046 trench coat +n04482393 tricycle, trike, velocipede +n04483307 trimaran +n04485082 tripod +n04486054 triumphal arch +n04487081 trolleybus, trolley coach, trackless trolley +n04487394 trombone +n04493381 tub, vat +n04501370 turnstile +n04505470 typewriter keyboard +n04507155 umbrella +n04509417 unicycle, monocycle +n04515003 upright, upright piano +n04517823 vacuum, vacuum cleaner +n04522168 vase +n04523525 vault +n04525038 velvet +n04525305 vending machine +n04532106 vestment +n04532670 viaduct +n04536866 violin, fiddle +n04540053 volleyball +n04542943 waffle iron +n04548280 wall clock +n04548362 wallet, billfold, notecase, pocketbook +n04550184 wardrobe, closet, press +n04552348 warplane, military plane +n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin +n04554684 washer, automatic washer, washing machine +n04557648 water bottle +n04560804 water jug +n04562935 water tower +n04579145 whiskey jug +n04579432 whistle +n04584207 wig +n04589890 window screen +n04590129 window shade +n04591157 Windsor tie +n04591713 wine bottle +n04592741 wing +n04596742 wok +n04597913 wooden spoon +n04599235 wool, woolen, woollen +n04604644 worm fence, snake fence, snake-rail fence, Virginia fence +n04606251 wreck +n04612504 yawl +n04613696 yurt +n06359193 web site, website, internet site, site +n06596364 comic book +n06785654 crossword puzzle, crossword +n06794110 street sign +n06874185 traffic light, traffic signal, stoplight +n07248320 book jacket, dust cover, dust jacket, dust wrapper +n07565083 menu +n07579787 plate +n07583066 guacamole +n07584110 consomme +n07590611 hot pot, hotpot +n07613480 trifle +n07614500 ice cream, icecream +n07615774 ice lolly, lolly, lollipop, popsicle +n07684084 French loaf +n07693725 bagel, beigel +n07695742 pretzel +n07697313 cheeseburger +n07697537 hotdog, hot dog, red hot +n07711569 mashed potato +n07714571 head cabbage +n07714990 broccoli +n07715103 cauliflower +n07716358 zucchini, courgette +n07716906 spaghetti squash +n07717410 acorn squash +n07717556 butternut squash +n07718472 cucumber, cuke +n07718747 artichoke, globe artichoke +n07720875 bell pepper +n07730033 cardoon +n07734744 mushroom +n07742313 Granny Smith +n07745940 strawberry +n07747607 orange +n07749582 lemon +n07753113 fig +n07753275 pineapple, ananas +n07753592 banana +n07754684 jackfruit, jak, jack +n07760859 custard apple +n07768694 pomegranate +n07802026 hay +n07831146 carbonara +n07836838 chocolate sauce, chocolate syrup +n07860988 dough +n07871810 meat loaf, meatloaf +n07873807 pizza, pizza pie +n07875152 potpie +n07880968 burrito +n07892512 red wine +n07920052 espresso +n07930864 cup +n07932039 eggnog +n09193705 alp +n09229709 bubble +n09246464 cliff, drop, drop-off +n09256479 coral reef +n09288635 geyser +n09332890 lakeside, lakeshore +n09399592 promontory, headland, head, foreland +n09421951 sandbar, sand bar +n09428293 seashore, coast, seacoast, sea-coast +n09468604 valley, vale +n09472597 volcano +n09835506 ballplayer, baseball player +n10148035 groom, bridegroom +n10565667 scuba diver +n11879895 rapeseed +n11939491 daisy +n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum +n12144580 corn +n12267677 acorn +n12620546 hip, rose hip, rosehip +n12768682 buckeye, horse chestnut, conker +n12985857 coral fungus +n12998815 agaric +n13037406 gyromitra +n13040303 stinkhorn, carrion fungus +n13044778 earthstar +n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa +n13054560 bolete +n13133613 ear, spike, capitulum +n15075141 toilet tissue, toilet paper, bathroom tissue diff --git a/session_3/openvino_notebooks/002-openvino-api/002-openvino-api.ipynb b/session_3/openvino_notebooks/002-openvino-api/002-openvino-api.ipynb new file mode 100644 index 0000000..c17ce42 --- /dev/null +++ b/session_3/openvino_notebooks/002-openvino-api/002-openvino-api.ipynb @@ -0,0 +1,852 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b875b31c", + "metadata": {}, + "source": [ + "# OpenVINO™ Runtime API Tutorial" + ] + }, + { + "cell_type": "markdown", + "id": "09abd9f4", + "metadata": {}, + "source": [ + "This notebook explains the basics of the OpenVINO Runtime API. It covers:\n", + "\n", + "- [Loading OpenVINO Runtime and Showing Info](#Loading-OpenVINO-Runtime-and-Showing-Info)\n", + "- [Loading a Model](#Loading-a-Model)\n", + " - [OpenVINO IR Model](#OpenVINO-IR-Model)\n", + " - [ONNX Model](#ONNX-Model)\n", + "- [Getting Information about a Model](#Getting-Information-about-a-Model)\n", + " - [Model Inputs](#Model-Inputs)\n", + " - [Model Outputs](#Model-Outputs)\n", + "- [Doing Inference on a Model](#Doing-Inference-on-a-Model)\n", + "- [Reshaping and Resizing](#Reshaping-and-Resizing)\n", + " - [Change Image Size](#Change-Image-Size)\n", + " - [Change Batch Size](#Change-Batch-Size)\n", + " - [Caching a Model](#Caching-a-Model)\n", + " \n", + "The notebook is divided into sections with headers. Each section is standalone and does not depend on previous sections. A segmentation and classification OpenVINO IR model and a segmentation ONNX model are provided as examples. These model files can be replaced with your own models. The exact outputs will be different, but the process is the same. " + ] + }, + { + "cell_type": "markdown", + "id": "9ed058f4", + "metadata": {}, + "source": [ + "## Loading OpenVINO Runtime and Showing Info\n", + "\n", + "Initialize OpenVINO Runtime with Core()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c08b79c4", + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import Core\n", + "\n", + "ie = Core()" + ] + }, + { + "cell_type": "markdown", + "id": "68bc4125", + "metadata": {}, + "source": [ + "OpenVINO Runtime can load a network on a device. A device in this context means a CPU, an Intel GPU, a Neural Compute Stick 2, etc. The `available_devices` property shows the available devices in your system. The \"FULL_DEVICE_NAME\" option to `ie.get_property()` shows the name of the device.\n", + "\n", + "In this notebook, the CPU device is used. To use an integrated GPU, use `device_name=\"GPU\"` instead. Be aware that loading a network on GPU will be slower than loading a network on CPU, but inference will likely be faster." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d0c94f76", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU: arm_compute::NEON\n", + "MYRIAD: Intel Movidius Myriad X VPU\n" + ] + } + ], + "source": [ + "devices = ie.available_devices\n", + "\n", + "for device in devices:\n", + " device_name = ie.get_property(device, \"FULL_DEVICE_NAME\")\n", + " print(f\"{device}: {device_name}\")" + ] + }, + { + "cell_type": "markdown", + "id": "14d62615", + "metadata": {}, + "source": [ + "## Loading a Model\n", + "\n", + "After initializing OpenVINO Runtime, first read the model file with `read_model()`, then compile it to the specified device with the `compile_model()` method. \n", + "\n", + "### OpenVINO IR Model\n", + "\n", + "An OpenVINO IR (Intermediate Representation) model consists of an `.xml` file, containing information about network topology, and a `.bin` file, containing the weights and biases binary data. The `read_model()` function expects the `.bin` weights file to have the same filename and be located in the same directory as the `.xml` file: `model_weights_file == Path(model_xml).with_suffix(\".bin\")`. If this is the case, specifying the weights file is optional. If the weights file has a different filename, it can be specified with the `weights` parameter to `read_model()`.\n", + "\n", + "For information on how to convert your existing TensorFlow, PyTorch or ONNX model to OpenVINO IR format with Model Optimizer, refer to the [tensorflow-to-openvino](../101-tensorflow-to-openvino/101-tensorflow-to-openvino.ipynb) and [pytorch-onnx-to-openvino](../102-pytorch-onnx-to-openvino/102-pytorch-onnx-to-openvino.ipynb) notebooks. For exporting ONNX models to OpenVINO IR with default settings, the `.serialize()` method can also be used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "523978fe", + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import Core\n", + "\n", + "ie = Core()\n", + "classification_model_xml = \"model/classification.xml\"\n", + "\n", + "model = ie.read_model(model=classification_model_xml)\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")" + ] + }, + { + "cell_type": "markdown", + "id": "e5516e87", + "metadata": {}, + "source": [ + "### ONNX Model\n", + "\n", + "Reading and loading an ONNX model, which is a single file, works the same way as with an OpenVINO IR model. The `model` argument points to the filename of an ONNX model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "15833f51", + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import Core\n", + "\n", + "ie = Core()\n", + "onnx_model_path = \"model/segmentation.onnx\"\n", + "\n", + "model_onnx = ie.read_model(model=onnx_model_path)\n", + "compiled_model_onnx = ie.compile_model(model=model_onnx, device_name=\"MYRIAD\")" + ] + }, + { + "cell_type": "markdown", + "id": "3d6a41d9-a2de-40a8-b925-fe3e817866d4", + "metadata": {}, + "source": [ + "The ONNX model can be exported to OpenVINO IR with `serialize():`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1610b254-8567-4409-9b26-259b8acd10dd", + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import serialize\n", + "\n", + "serialize(model=model, xml_path=\"model/exported_onnx_model.xml\", bin_path=\"model/exported_onnx_model.bin\")" + ] + }, + { + "cell_type": "markdown", + "id": "8ebee450", + "metadata": { + "tags": [] + }, + "source": [ + "## Getting Information about a Model\n", + "\n", + "The OpenVINO IENetwork instance stores information about the model. Information about the inputs and outputs of the model are in `model.inputs` and `model.outputs`. These are also properties of the ExecutableNetwork instance. While using `model.inputs` and `model.outputs` in the cells below, you can also use `compiled_model.inputs` and `compiled_model.outputs`." + ] + }, + { + "cell_type": "markdown", + "id": "edc79b32", + "metadata": {}, + "source": [ + "### Model Inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5571614d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'input'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from openvino.runtime import Core\n", + "\n", + "ie = Core()\n", + "classification_model_xml = \"model/classification.xml\"\n", + "model = ie.read_model(model=classification_model_xml)\n", + "model.input(0).any_name" + ] + }, + { + "cell_type": "markdown", + "id": "4ebb1299", + "metadata": {}, + "source": [ + "The cell above shows that the model loaded expects one input, with the name _input_. If you loaded a different model, you may see a different input layer name, and you may see more inputs.\n", + "\n", + "It is often useful to have a reference to the name of the first input layer. For a model with one input, `model.input(0)` gets this name." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6cf48354", + "metadata": {}, + "outputs": [], + "source": [ + "input_layer = model.input(0)" + ] + }, + { + "cell_type": "markdown", + "id": "aea90446", + "metadata": {}, + "source": [ + "Information for this input layer is stored in `inputs`. The next cell prints the input layout, precision and a shape." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bd0bc0c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input precision: \n", + "input shape: {1, 3, 224, 224}\n" + ] + } + ], + "source": [ + "print(f\"input precision: {input_layer.element_type}\")\n", + "print(f\"input shape: {input_layer.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d189a73c", + "metadata": {}, + "source": [ + "This cell shows that the model expects inputs with a shape of [1,3,224,224], and that this is in the `NCHW` layout. This means that the model expects input data with the batch size of 1 (`N`), 3 channels (`C`) , and images with a height (`H`) and width (`W`) equal to 224. The input data is expected to be of `FP32` (floating point) precision." + ] + }, + { + "cell_type": "markdown", + "id": "155cf48e", + "metadata": {}, + "source": [ + "### Model Outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4583eb0e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'MobilenetV3/Predictions/Softmax'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from openvino.runtime import Core\n", + "\n", + "ie = Core()\n", + "classification_model_xml = \"model/classification.xml\"\n", + "model = ie.read_model(model=classification_model_xml)\n", + "model.output(0).any_name" + ] + }, + { + "cell_type": "markdown", + "id": "a189c02f", + "metadata": {}, + "source": [ + "Model output info is stored in `model.outputs`. The cell above shows that the model returns one output, with the `MobilenetV3/Predictions/Softmax` name. Loading a different model will result in different output layer name, and more outputs might be returned.\n", + "\n", + "Since this model has one output, follow the same method as for the input layer to get its name." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "88fbbd06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_layer = model.output(0)\n", + "output_layer" + ] + }, + { + "cell_type": "markdown", + "id": "16ad0240", + "metadata": {}, + "source": [ + "Getting the output precision and shape is similar to getting the input precision and shape." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0ee5e14a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "output precision: \n", + "output shape: {1, 1001}\n" + ] + } + ], + "source": [ + "print(f\"output precision: {output_layer.element_type}\")\n", + "print(f\"output shape: {output_layer.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2739f5bb", + "metadata": {}, + "source": [ + "This cell shows that the model returns outputs with a shape of [1, 1001], where 1 is the batch size (`N`) and 1001 is the number of classes (`C`). The output is returned as 32-bit floating point." + ] + }, + { + "cell_type": "markdown", + "id": "021708ab", + "metadata": {}, + "source": [ + "## Doing Inference on a Model\n", + "\n", + "To do inference on a model, first create an inference request by calling the `create_infer_request()` method of `ExecutableNetwork`, `exec_net` that was loaded with `compile_model()`. Then, call the `infer()` method of `InferRequest`. It expects one argument: `inputs`. This is a dictionary that maps input layer names to input data." + ] + }, + { + "cell_type": "markdown", + "id": "3ec2eac8", + "metadata": {}, + "source": [ + "**Load the network**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "298c80b5", + "metadata": {}, + "outputs": [], + "source": [ + "from openvino.runtime import Core\n", + "\n", + "ie = Core()\n", + "classification_model_xml = \"model/classification.xml\"\n", + "model = ie.read_model(model=classification_model_xml)\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")\n", + "input_layer = compiled_model.input(0)\n", + "output_layer = compiled_model.output(0)" + ] + }, + { + "cell_type": "markdown", + "id": "173cd1c9", + "metadata": {}, + "source": [ + "**Load an image and convert to the input shape**\n", + "\n", + "To propagate an image through the network, it needs to be loaded into an array, resized to the shape that the network expects, and converted to the input layout of the network." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1f23c43a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(663, 994, 3)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import cv2\n", + "\n", + "image_filename = \"data/coco_hollywood.jpg\"\n", + "image = cv2.imread(image_filename)\n", + "image.shape" + ] + }, + { + "cell_type": "markdown", + "id": "6bf541d8", + "metadata": {}, + "source": [ + "The image has a shape of (663,994,3). It is 663 pixels in height, 994 pixels in width, and has 3 color channels. A reference to the height and width expected by the network is obtained and the image is resized to these dimensions." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c9f97da2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(224, 224, 3)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# N,C,H,W = batch size, number of channels, height, width.\n", + "N, C, H, W = input_layer.shape\n", + "# OpenCV resize expects the destination size as (width, height).\n", + "resized_image = cv2.resize(src=image, dsize=(W, H))\n", + "resized_image.shape" + ] + }, + { + "cell_type": "markdown", + "id": "436a6d74", + "metadata": {}, + "source": [ + "Now, the image has the width and height that the network expects. This is still in `HWC` format and must be changed to `NCHW` format. First, call the `np.transpose()` method to change to `CHW` and then add the `N` dimension (where `N`= 1) by calling the `np.expand_dims()` method. Next, convert the data to `FP32` with `np.astype()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d09b7275", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 3, 224, 224)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "input_data = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0).astype(np.float32)\n", + "input_data.shape" + ] + }, + { + "cell_type": "markdown", + "id": "af110efb", + "metadata": {}, + "source": [ + "**Do inference**\n", + "\n", + "Now that the input data is in the right shape, do the inference." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "098c8cb2", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "result = compiled_model([input_data])[output_layer]" + ] + }, + { + "cell_type": "markdown", + "id": "978a131e", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "You can also create `InferRequest` and run `infer` method on request." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "bf94022c", + "metadata": {}, + "outputs": [], + "source": [ + "request = compiled_model.create_infer_request()\n", + "request.infer(inputs={input_layer.any_name: input_data})\n", + "result = request.get_output_tensor(output_layer.index).data" + ] + }, + { + "cell_type": "markdown", + "id": "53bf7c61", + "metadata": {}, + "source": [ + "The `.infer()` function sets output tensor, that can be reached, using `get_output_tensor()`. Since this network returns one output, and the reference to the output layer is in the `output_layer.index` parameter, you can get the data with `request.get_output_tensor(output_layer.index)`. To get a numpy array from the output, use the `.data` parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4a0f63b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 1001)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.shape" + ] + }, + { + "cell_type": "markdown", + "id": "7e5834ee", + "metadata": {}, + "source": [ + "The output shape is (1,1001), which is the expected output shape. This shape indicates that the network returns probabilities for 1001 classes. To learn more about this notion, refer to the [hello world notebook](../001-hello-world/001-hello-world.ipynb)." + ] + }, + { + "cell_type": "markdown", + "id": "ec6a9be1", + "metadata": {}, + "source": [ + "## Reshaping and Resizing\n", + "\n", + "### Change Image Size" + ] + }, + { + "cell_type": "markdown", + "id": "4239b10c", + "metadata": {}, + "source": [ + "Instead of reshaping the image to fit the model, it is also possible to reshape the model to fit the image. Be aware that not all models support reshaping, and models that do, may not support all input shapes. The model accuracy may also suffer if you reshape the model input shape.\n", + "\n", + "First check the input shape of the model, then reshape it to the new input shape." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "bc1a69f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "~~~~ ORIGINAL MODEL ~~~~\n", + "input shape: {1, 3, 512, 512}\n", + "output shape: {1, 1, 512, 512}\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "[ GENERAL_ERROR ] \n/Users/chepe/hackerdojo/pythonista/openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:594 Failed to compile layer \"Conv_0/WithoutBiases/fq_input_0\": unsupported layer type \"FakeQuantize\"", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0mnew_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPartialShape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m544\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m544\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0msegmentation_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0msegmentation_input_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnew_shape\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0msegmentation_compiled_model\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mie\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msegmentation_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"MYRIAD\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;31m# help(segmentation_compiled_model)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"~~~~ RESHAPED MODEL ~~~~\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.virtualenvs/openvino/lib/python3.10/site-packages/openvino/runtime/ie_api.py\u001b[0m in \u001b[0;36mcompile_model\u001b[0;34m(self, model, device_name, config)\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 385\u001b[0m return CompiledModel(\n\u001b[0;32m--> 386\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mconfig\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 387\u001b[0m )\n\u001b[1;32m 388\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: [ GENERAL_ERROR ] \n/Users/chepe/hackerdojo/pythonista/openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:594 Failed to compile layer \"Conv_0/WithoutBiases/fq_input_0\": unsupported layer type \"FakeQuantize\"" + ] + } + ], + "source": [ + "from openvino.runtime import Core, PartialShape\n", + "\n", + "ie = Core()\n", + "segmentation_model_xml = \"model/segmentation.xml\"\n", + "segmentation_model = ie.read_model(model=segmentation_model_xml)\n", + "segmentation_input_layer = segmentation_model.input(0)\n", + "segmentation_output_layer = segmentation_model.output(0)\n", + "\n", + "print(\"~~~~ ORIGINAL MODEL ~~~~\")\n", + "print(f\"input shape: {segmentation_input_layer.shape}\")\n", + "print(f\"output shape: {segmentation_output_layer.shape}\")\n", + "\n", + "new_shape = PartialShape([1, 3, 544, 544])\n", + "segmentation_model.reshape({segmentation_input_layer.any_name: new_shape})\n", + "segmentation_compiled_model = ie.compile_model(model=segmentation_model, device_name=\"MYRIAD\")\n", + "# help(segmentation_compiled_model)\n", + "print(\"~~~~ RESHAPED MODEL ~~~~\")\n", + "print(f\"model input shape: {segmentation_input_layer.shape}\")\n", + "print(\n", + " f\"compiled_model input shape: \"\n", + " f\"{segmentation_compiled_model.input(index=0).shape}\"\n", + ")\n", + "print(f\"compiled_model output shape: {segmentation_output_layer.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2104cef6", + "metadata": {}, + "source": [ + "The input shape for the segmentation network is [1,3,512,512], with the `NCHW` layout: the network expects 3-channel images with a width and height of 512 and a batch size of 1. Reshape the network with the `.reshape()` method of `IENetwork` to make it accept input images with a width and height of 544. This segmentation network always returns arrays with the input width and height of equal value. Therefore, setting the input dimensions to 544x544 also modifies the output dimensions. After reshaping, compile the network once again." + ] + }, + { + "cell_type": "markdown", + "id": "249d697a", + "metadata": {}, + "source": [ + "### Change Batch Size" + ] + }, + { + "cell_type": "markdown", + "id": "ded79c8f", + "metadata": {}, + "source": [ + "Use the `.reshape()` method to set the batch size, by increasing the first element of `new_shape`. For example, to set a batch size of two, set `new_shape = (2,3,544,544)` in the cell above. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a49d65c6", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "[ GENERAL_ERROR ] \n/Users/chepe/hackerdojo/pythonista/openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:594 Failed to compile layer \"Conv_0/WithoutBiases/fq_input_0\": unsupported layer type \"FakeQuantize\"", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mnew_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPartialShape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m544\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m544\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0msegmentation_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0msegmentation_input_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnew_shape\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0msegmentation_compiled_model\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mie\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msegmentation_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"MYRIAD\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"input shape: {segmentation_input_layer.shape}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.virtualenvs/openvino/lib/python3.10/site-packages/openvino/runtime/ie_api.py\u001b[0m in \u001b[0;36mcompile_model\u001b[0;34m(self, model, device_name, config)\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 385\u001b[0m return CompiledModel(\n\u001b[0;32m--> 386\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mconfig\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 387\u001b[0m )\n\u001b[1;32m 388\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: [ GENERAL_ERROR ] \n/Users/chepe/hackerdojo/pythonista/openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:594 Failed to compile layer \"Conv_0/WithoutBiases/fq_input_0\": unsupported layer type \"FakeQuantize\"" + ] + } + ], + "source": [ + "from openvino.runtime import Core, PartialShape\n", + "\n", + "ie = Core()\n", + "segmentation_model_xml = \"model/segmentation.xml\"\n", + "segmentation_model = ie.read_model(model=segmentation_model_xml)\n", + "segmentation_input_layer = segmentation_model.input(0)\n", + "segmentation_output_layer = segmentation_model.output(0)\n", + "new_shape = PartialShape([2, 3, 544, 544])\n", + "segmentation_model.reshape({segmentation_input_layer.any_name: new_shape})\n", + "segmentation_compiled_model = ie.compile_model(model=segmentation_model, device_name=\"MYRIAD\")\n", + "\n", + "print(f\"input shape: {segmentation_input_layer.shape}\")\n", + "print(f\"output shape: {segmentation_output_layer.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "40c2f3d2", + "metadata": {}, + "source": [ + "The output shows that by setting the batch size to 2, the first element (`N`) of the input and output shape has a value of 2. Propagate the input image through the network to see the result:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0eb487fa", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from openvino.runtime import Core, PartialShape\n", + "\n", + "ie = Core()\n", + "segmentation_model_xml = \"model/segmentation.xml\"\n", + "segmentation_model = ie.read_model(model=segmentation_model_xml)\n", + "segmentation_input_layer = segmentation_model.input(0)\n", + "segmentation_output_layer = segmentation_model.output(0)\n", + "new_shape = PartialShape([2, 3, 544, 544])\n", + "segmentation_model.reshape({segmentation_input_layer.any_name: new_shape})\n", + "segmentation_compiled_model = ie.compile_model(model=segmentation_model, device_name=\"CPU\")\n", + "input_data = np.random.rand(2, 3, 544, 544)\n", + "\n", + "output = segmentation_compiled_model([input_data])\n", + "\n", + "print(f\"input data shape: {input_data.shape}\")\n", + "print(f\"result data data shape: {segmentation_output_layer.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a9657dc5-9713-4d2b-a324-c8cd6195e79a", + "metadata": {}, + "source": [ + "## Caching a Model\n", + "\n", + "For some devices, like GPU, loading a model can take some time. Model Caching solves this issue by caching the model in a cache directory. If `ie.compile_model(model=net, device_name=device_name, config=config_dict)` is set, caching will be used. This option checks if a model exists in the cache. If so, it loads it from the cache. If not, it loads the model regularly, and stores it in the cache, so that the next time the model is loaded when this option is set, the model will be loaded from the cache.\n", + "\n", + "In the cell below, we create a *model_cache* directory as a subdirectory of *model*, where the model will be cached for the specified device. The model will be loaded to the GPU. After running this cell once, the model will be cached, so subsequent runs of this cell will load the model from the cache.\n", + "\n", + "*Note: Model Caching is also available on CPU devices*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d235185-18f7-4cf0-8cb2-1ecba279318a", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "from pathlib import Path\n", + "\n", + "from openvino.runtime import Core\n", + "\n", + "ie = Core()\n", + "\n", + "device_name = \"GPU\" \n", + "\n", + "if device_name in ie.available_devices:\n", + " cache_path = Path(\"model/model_cache\")\n", + " cache_path.mkdir(exist_ok=True)\n", + " # Enable caching for OpenVINO Runtime. To disable caching set enable_caching = False\n", + " enable_caching = True\n", + " config_dict = {\"CACHE_DIR\": str(cache_path)} if enable_caching else {}\n", + "\n", + " classification_model_xml = \"model/classification.xml\"\n", + " model = ie.read_model(model=classification_model_xml)\n", + "\n", + " start_time = time.perf_counter()\n", + " compiled_model = ie.compile_model(model=model, device_name=device_name, config=config_dict)\n", + " end_time = time.perf_counter()\n", + " print(f\"Loading the network to the {device_name} device took {end_time-start_time:.2f} seconds.\")" + ] + }, + { + "cell_type": "markdown", + "id": "48e0a860-c93c-4b93-a684-f53cd66ec2e3", + "metadata": {}, + "source": [ + "After running the previous cell, we know the model exists in the cache directory. We delete the compiled model and load it again. We measure the time it takes now." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5a7686b-b9e0-44a6-8b6e-5b299d085eac", + "metadata": {}, + "outputs": [], + "source": [ + "if device_name in ie.available_devices:\n", + " del compiled_model\n", + " start_time = time.perf_counter()\n", + " compiled_model = ie.compile_model(model=model, device_name=device_name, config=config_dict)\n", + " end_time = time.perf_counter()\n", + " print(f\"Loading the network to the {device_name} device took {end_time-start_time:.2f} seconds.\")" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "ae617ccb002f72b3ab6d0069d721eac67ac2a969e83c083c4321cfcab0437cd1" + }, + "kernelspec": { + "display_name": "Python 3", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/session_3/openvino_notebooks/002-openvino-api/README.md b/session_3/openvino_notebooks/002-openvino-api/README.md new file mode 100644 index 0000000..632d1b7 --- /dev/null +++ b/session_3/openvino_notebooks/002-openvino-api/README.md @@ -0,0 +1,29 @@ +# OpenVINO™ API tutorial + +[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/openvinotoolkit/openvino_notebooks/HEAD?filepath=notebooks%2F002-openvino-api%2F002-openvino-api.ipynb) + + +This notebook explains the basics of the OpenVINO Runtime API. +It provides a segmentation and classification IR model and a segmentation ONNX model. The model files can be replaced with your own models. + +Despite the exact output being different, the process remains the same. + +## Notebook Contents + +The OpenVINO API tutorial consists of the following steps: + +* Loading OpenVINO Runtime and Showing Info +* Loading a Model + * OpenVINO IR Model + * ONNX Model +* Getting Information about a Model + * Model Inputs + * Model Outputs +* Doing Inference on a Model +* Reshaping and Resizing + * Change Image Size + * Change Batch Size + +## Installation Instructions + +If you have not installed all required dependencies, follow the [Installation Guide](../../README.md). diff --git a/session_3/openvino_notebooks/002-openvino-api/data/coco_cross.png b/session_3/openvino_notebooks/002-openvino-api/data/coco_cross.png new file mode 100644 index 0000000..7e46b90 Binary files /dev/null and b/session_3/openvino_notebooks/002-openvino-api/data/coco_cross.png differ diff --git a/session_3/openvino_notebooks/002-openvino-api/data/coco_hollywood.jpg b/session_3/openvino_notebooks/002-openvino-api/data/coco_hollywood.jpg new file mode 100644 index 0000000..2e2a3f4 Binary files /dev/null and b/session_3/openvino_notebooks/002-openvino-api/data/coco_hollywood.jpg differ diff --git a/session_3/openvino_notebooks/002-openvino-api/model/classification.bin b/session_3/openvino_notebooks/002-openvino-api/model/classification.bin new file mode 100644 index 0000000..1206940 Binary files /dev/null and b/session_3/openvino_notebooks/002-openvino-api/model/classification.bin differ diff --git a/session_3/openvino_notebooks/002-openvino-api/model/classification.xml b/session_3/openvino_notebooks/002-openvino-api/model/classification.xml new file mode 100644 index 0000000..c7ab234 --- /dev/null +++ b/session_3/openvino_notebooks/002-openvino-api/model/classification.xml @@ -0,0 +1,6140 @@ + + + + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 1 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 3 + 1 + 1 + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 16 + 3 + 3 + 3 + + + + + + + + 1 + 3 + 224 + 224 + + + 16 + 3 + 3 + 3 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 112 + 112 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 112 + 112 + + + + + + + 1 + 16 + 112 + 112 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 16 + 1 + 1 + 3 + 3 + + + + + + + + 1 + 16 + 112 + 112 + + + 16 + 1 + 1 + 3 + 3 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 8 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + 8 + 16 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 16 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + 16 + 8 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 16 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 16 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 72 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 72 + 16 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 56 + 56 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + 1 + 72 + 56 + 56 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 72 + 1 + 1 + 3 + 3 + + + + + + + + 1 + 72 + 56 + 56 + + + 72 + 1 + 1 + 3 + 3 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 28 + 28 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 28 + 28 + + + + + + + 1 + 72 + 28 + 28 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 24 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 28 + 28 + + + 24 + 72 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 88 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 88 + 24 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 88 + 1 + 1 + 3 + 3 + + + + + + + + 1 + 88 + 28 + 28 + + + 88 + 1 + 1 + 3 + 3 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 24 + 88 + 1 + 1 + + + + + + + + 1 + 88 + 28 + 28 + + + 24 + 88 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 28 + 28 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 28 + 28 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + 1 + 96 + 28 + 28 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 96 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 96 + 28 + 28 + + + 96 + 1 + 1 + 5 + 5 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 24 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + 24 + 96 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 40 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 14 + 14 + + + 40 + 96 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 120 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 120 + 40 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 120 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 120 + 14 + 14 + + + 120 + 1 + 1 + 5 + 5 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 32 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + 32 + 120 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 120 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + 120 + 32 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 48 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 48 + 120 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 144 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 144 + 48 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 144 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 144 + 14 + 14 + + + 144 + 1 + 1 + 5 + 5 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 40 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 40 + 144 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 144 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + 144 + 40 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 48 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 48 + 144 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 14 + 14 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 288 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 288 + 48 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 14 + 14 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + 1 + 288 + 14 + 14 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 288 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 288 + 14 + 14 + + + 288 + 1 + 1 + 5 + 5 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 72 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + 72 + 288 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 288 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + 288 + 72 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 96 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 7 + 7 + + + 96 + 288 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1024 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1024 + 576 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1001 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + 1001 + 1024 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 1 + 1001 + 1 + 1 + + + 1 + 1001 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 4 + + + + + + + 1 + 1001 + 1 + 1 + + + 4 + + + + + 1 + 1 + 1 + 1001 + + + + + + + + 2 + + + + + + + 1 + 1 + 1 + 1001 + + + 2 + + + + + 1 + 1001 + + + + + + + + 2 + + + + + + + + 1 + 1001 + + + 2 + + + + + 1 + 1001 + + + + + + + + 1 + 1001 + + + + + 1 + 1001 + + + + + + + 1 + 1001 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_3/openvino_notebooks/002-openvino-api/model/exported_onnx_model.bin b/session_3/openvino_notebooks/002-openvino-api/model/exported_onnx_model.bin new file mode 100644 index 0000000..1206940 Binary files /dev/null and b/session_3/openvino_notebooks/002-openvino-api/model/exported_onnx_model.bin differ diff --git a/session_3/openvino_notebooks/002-openvino-api/model/exported_onnx_model.xml b/session_3/openvino_notebooks/002-openvino-api/model/exported_onnx_model.xml new file mode 100644 index 0000000..631d86b --- /dev/null +++ b/session_3/openvino_notebooks/002-openvino-api/model/exported_onnx_model.xml @@ -0,0 +1,6143 @@ + + + + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 3 + 224 + 224 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 1 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 1 + 3 + 1 + 1 + + + + + + + + 1 + 3 + 224 + 224 + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 224 + 224 + + + + + + + + 16 + 3 + 3 + 3 + + + + + + + + 1 + 3 + 224 + 224 + + + 16 + 3 + 3 + 3 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 112 + 112 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 112 + 112 + + + + + + + 1 + 16 + 112 + 112 + + + + + 1 + 16 + 112 + 112 + + + + + + + + 16 + 1 + 1 + 3 + 3 + + + + + + + + 1 + 16 + 112 + 112 + + + 16 + 1 + 1 + 3 + 3 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 56 + 56 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 8 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + 8 + 16 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + 1 + 8 + 1 + 1 + + + + + 1 + 8 + 1 + 1 + + + + + + + + 16 + 8 + 1 + 1 + + + + + + + + 1 + 8 + 1 + 1 + + + 16 + 8 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 16 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 16 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 16 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 56 + 56 + + + + + + + + 72 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 56 + 56 + + + 72 + 16 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 56 + 56 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 56 + 56 + + + + + + + 1 + 72 + 56 + 56 + + + + + 1 + 72 + 56 + 56 + + + + + + + + 72 + 1 + 1 + 3 + 3 + + + + + + + + 1 + 72 + 56 + 56 + + + 72 + 1 + 1 + 3 + 3 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 28 + 28 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 28 + 28 + + + + + + + 1 + 72 + 28 + 28 + + + + + 1 + 72 + 28 + 28 + + + + + + + + 24 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 28 + 28 + + + 24 + 72 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 88 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 88 + 24 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 88 + 1 + 1 + 3 + 3 + + + + + + + + 1 + 88 + 28 + 28 + + + 88 + 1 + 1 + 3 + 3 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 1 + 88 + 1 + 1 + + + + + + + + 1 + 88 + 28 + 28 + + + 1 + 88 + 1 + 1 + + + + + 1 + 88 + 28 + 28 + + + + + + + 1 + 88 + 28 + 28 + + + + + 1 + 88 + 28 + 28 + + + + + + + + 24 + 88 + 1 + 1 + + + + + + + + 1 + 88 + 28 + 28 + + + 24 + 88 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 1 + 24 + 28 + 28 + + + 1 + 24 + 28 + 28 + + + + + 1 + 24 + 28 + 28 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 28 + 28 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 28 + 28 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 28 + 28 + + + + + + + 1 + 96 + 28 + 28 + + + + + 1 + 96 + 28 + 28 + + + + + + + + 96 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 96 + 28 + 28 + + + 96 + 1 + 1 + 5 + 5 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 1 + 96 + 14 + 14 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 24 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + 24 + 96 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + 1 + 24 + 1 + 1 + + + + + 1 + 24 + 1 + 1 + + + + + + + + 96 + 24 + 1 + 1 + + + + + + + + 1 + 24 + 1 + 1 + + + 96 + 24 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 96 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 14 + 14 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 14 + 14 + + + + + + + + 40 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 14 + 14 + + + 40 + 96 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 240 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 240 + 40 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 240 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 240 + 14 + 14 + + + 240 + 1 + 1 + 5 + 5 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 1 + 240 + 14 + 14 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 64 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 64 + 240 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 240 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 1 + 1 + + + 240 + 64 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 240 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 1 + 240 + 1 + 1 + + + + + 1 + 240 + 14 + 14 + + + + + + + + 40 + 240 + 1 + 1 + + + + + + + + 1 + 240 + 14 + 14 + + + 40 + 240 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 1 + 40 + 14 + 14 + + + 1 + 40 + 14 + 14 + + + + + 1 + 40 + 14 + 14 + + + + + + + + 120 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 14 + 14 + + + 120 + 40 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 120 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 120 + 14 + 14 + + + 120 + 1 + 1 + 5 + 5 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 1 + 120 + 14 + 14 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 32 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + 32 + 120 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 120 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 1 + 1 + + + 120 + 32 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 120 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 1 + 120 + 1 + 1 + + + + + 1 + 120 + 14 + 14 + + + + + + + + 48 + 120 + 1 + 1 + + + + + + + + 1 + 120 + 14 + 14 + + + 48 + 120 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 144 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 144 + 48 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 144 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 144 + 14 + 14 + + + 144 + 1 + 1 + 5 + 5 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 1 + 144 + 14 + 14 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 40 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 40 + 144 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + 1 + 40 + 1 + 1 + + + + + 1 + 40 + 1 + 1 + + + + + + + + 144 + 40 + 1 + 1 + + + + + + + + 1 + 40 + 1 + 1 + + + 144 + 40 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 14 + 14 + + + + + + + + 48 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 14 + 14 + + + 48 + 144 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 1 + 1 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 1 + 48 + 14 + 14 + + + 1 + 48 + 14 + 14 + + + + + 1 + 48 + 14 + 14 + + + + + + + + 288 + 48 + 1 + 1 + + + + + + + + 1 + 48 + 14 + 14 + + + 288 + 48 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 14 + 14 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 14 + 14 + + + + + + + 1 + 288 + 14 + 14 + + + + + 1 + 288 + 14 + 14 + + + + + + + + 288 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 288 + 14 + 14 + + + 288 + 1 + 1 + 5 + 5 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 1 + 288 + 7 + 7 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 72 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + 72 + 288 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + 1 + 72 + 1 + 1 + + + + + 1 + 72 + 1 + 1 + + + + + + + + 288 + 72 + 1 + 1 + + + + + + + + 1 + 72 + 1 + 1 + + + 288 + 72 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 288 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 7 + 7 + + + 1 + 288 + 1 + 1 + + + + + 1 + 288 + 7 + 7 + + + + + + + + 96 + 288 + 1 + 1 + + + + + + + + 1 + 288 + 7 + 7 + + + 96 + 288 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 576 + 1 + 1 + 5 + 5 + + + + + + + + 1 + 576 + 7 + 7 + + + 576 + 1 + 1 + 5 + 5 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 144 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 144 + 576 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + 1 + 144 + 1 + 1 + + + + + 1 + 144 + 1 + 1 + + + + + + + + 576 + 144 + 1 + 1 + + + + + + + + 1 + 144 + 1 + 1 + + + 576 + 144 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 96 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 96 + 576 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 1 + 1 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 1 + 96 + 7 + 7 + + + 1 + 96 + 7 + 7 + + + + + 1 + 96 + 7 + 7 + + + + + + + + 576 + 96 + 1 + 1 + + + + + + + + 1 + 96 + 7 + 7 + + + 576 + 96 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 7 + 7 + + + 1 + 576 + 1 + 1 + + + + + 1 + 576 + 7 + 7 + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 7 + 7 + + + + + + + + 1 + 576 + 7 + 7 + + + + + 1 + 576 + 1 + 1 + + + + + + + + 1024 + 576 + 1 + 1 + + + + + + + + 1 + 576 + 1 + 1 + + + 1024 + 576 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + + + 1 + 1024 + 1 + 1 + + + + + + + + 1001 + 1024 + 1 + 1 + + + + + + + + 1 + 1024 + 1 + 1 + + + 1001 + 1024 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 1 + 1001 + 1 + 1 + + + 1 + 1001 + 1 + 1 + + + + + 1 + 1001 + 1 + 1 + + + + + + + + 4 + + + + + + + 1 + 1001 + 1 + 1 + + + 4 + + + + + 1 + 1 + 1 + 1001 + + + + + + + + 2 + + + + + + + 1 + 1 + 1 + 1001 + + + 2 + + + + + 1 + 1001 + + + + + + + + 2 + + + + + + + + 1 + 1001 + + + 2 + + + + + 1 + 1001 + + + + + + + + 1 + 1001 + + + + + 1 + 1001 + + + + + + + + 1 + 1001 + + + + + 1 + 1001 + + + + + + + 1 + 1001 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_3/openvino_notebooks/002-openvino-api/model/segmentation.bin b/session_3/openvino_notebooks/002-openvino-api/model/segmentation.bin new file mode 100644 index 0000000..2deee19 Binary files /dev/null and b/session_3/openvino_notebooks/002-openvino-api/model/segmentation.bin differ diff --git a/session_3/openvino_notebooks/002-openvino-api/model/segmentation.onnx b/session_3/openvino_notebooks/002-openvino-api/model/segmentation.onnx new file mode 100644 index 0000000..3397812 Binary files /dev/null and b/session_3/openvino_notebooks/002-openvino-api/model/segmentation.onnx differ diff --git a/session_3/openvino_notebooks/002-openvino-api/model/segmentation.xml b/session_3/openvino_notebooks/002-openvino-api/model/segmentation.xml new file mode 100644 index 0000000..30b6942 --- /dev/null +++ b/session_3/openvino_notebooks/002-openvino-api/model/segmentation.xml @@ -0,0 +1,51741 @@ + + + + + + + + 1 + 3 + 512 + 512 + + + + + + + + 1 + 3 + 1 + 1 + + + + + + + + 1 + 3 + 512 + 512 + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 512 + 512 + + + + + + + + 1 + 3 + 1 + 1 + + + + + + + + 1 + 3 + 512 + 512 + + + 1 + 3 + 1 + 1 + + + + + 1 + 3 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 3 + 512 + 512 + + + + + + + + + 1 + 3 + 512 + 512 + + + + + + + + 64 + 3 + 3 + 3 + + + + + + + + 64 + 3 + 3 + 3 + + + + + 64 + 3 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 3 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 3 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 3 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 3 + 3 + 3 + + + + + + + + 1 + 3 + 512 + 512 + + + 64 + 3 + 3 + 3 + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 512 + 512 + + + + + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 512 + 512 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 512 + 512 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 512 + 512 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 512 + 512 + + + + + + + 1 + 16 + 512 + 512 + + + + + 1 + 16 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + 1 + 16 + 512 + 512 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 256 + 256 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 256 + 256 + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 128 + 128 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 64 + 64 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 128 + 128 + + + + + 1 + 32 + 128 + 128 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 128 + 128 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 256 + 256 + + + + + 1 + 32 + 256 + 256 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 256 + 256 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 256 + 256 + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 256 + 256 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + 1 + 16 + 512 + 512 + + + 1 + 16 + 512 + 512 + + + + + 1 + 32 + 512 + 512 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 512 + 512 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 512 + 512 + + + + + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 256 + 256 + + + + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 64 + 3 + 3 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 256 + 256 + + + 64 + 64 + 3 + 3 + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 256 + 256 + + + + + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 256 + 256 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 256 + 256 + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 128 + 128 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 64 + 64 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 128 + 128 + + + + + 1 + 32 + 128 + 128 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 128 + 128 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 256 + 256 + + + + + 1 + 32 + 256 + 256 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 256 + 256 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 256 + 256 + + + + + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 128 + 128 + + + + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 64 + 3 + 3 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 128 + 128 + + + 64 + 64 + 3 + 3 + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 128 + 128 + + + + + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 128 + 128 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 64 + 64 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 128 + 128 + + + + + 1 + 32 + 128 + 128 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 128 + 128 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 128 + 128 + + + + + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 64 + 64 + + + + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 64 + 3 + 3 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 64 + 64 + + + 64 + 64 + 3 + 3 + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 64 + 64 + + + + + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 64 + 64 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 64 + 64 + + + + + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 32 + 32 + + + + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 64 + 3 + 3 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 32 + 32 + + + 64 + 64 + 3 + 3 + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 32 + 32 + + + + + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 32 + 32 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 32 + 32 + + + + + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 16 + 16 + + + + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 64 + 3 + 3 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 64 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 16 + 16 + + + 64 + 64 + 3 + 3 + + + + + 1 + 64 + 16 + 16 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 16 + 16 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 16 + 16 + + + + + + + 1 + 64 + 16 + 16 + + + + + 1 + 64 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 16 + 16 + + + + + + + + + 1 + 64 + 16 + 16 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 16 + 16 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 16 + 16 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 16 + 16 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 16 + 16 + + + + + + + 1 + 64 + 16 + 16 + + + + + 1 + 64 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 16 + 16 + + + + + + + + + 1 + 64 + 16 + 16 + + + + + + + + 1 + 64 + 16 + 16 + + + 1 + 64 + 16 + 16 + + + + + 1 + 64 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 16 + 16 + + + + + + + + + 1 + 64 + 16 + 16 + + + + + + + + 1 + 64 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 64 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 64 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 64 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 64 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 32 + 32 + + + + + 1 + 128 + 32 + 32 + + + + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 128 + 3 + 3 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 1 + 128 + 32 + 32 + + + 64 + 128 + 3 + 3 + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 32 + 32 + + + + + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 32 + 32 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 32 + 32 + + + + + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 32 + 32 + + + + + 1 + 64 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + + 1 + 64 + 32 + 32 + + + + + + + + 1 + 64 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 64 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 64 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 64 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 64 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 64 + 64 + + + + + 1 + 128 + 64 + 64 + + + + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 128 + 3 + 3 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 1 + 128 + 64 + 64 + + + 64 + 128 + 3 + 3 + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 64 + 64 + + + + + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 64 + 64 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 64 + 64 + + + + + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 64 + 64 + + + + + 1 + 64 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + + 1 + 64 + 64 + 64 + + + + + + + + 1 + 64 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 64 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 64 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 64 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 64 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 128 + 128 + + + + + 1 + 128 + 128 + 128 + + + + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 128 + 3 + 3 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 1 + 128 + 128 + 128 + + + 64 + 128 + 3 + 3 + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 128 + 128 + + + + + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 128 + 128 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 64 + 64 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 128 + 128 + + + + + 1 + 32 + 128 + 128 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 128 + 128 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 128 + 128 + + + + + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 128 + 128 + + + + + 1 + 64 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + + 1 + 64 + 128 + 128 + + + + + + + + 1 + 64 + 128 + 128 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 64 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 64 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 64 + 128 + 128 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 64 + 128 + 128 + + + 2 + + + 2 + + + 2 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 256 + 256 + + + + + 1 + 128 + 256 + 256 + + + + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 128 + 3 + 3 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 1 + 128 + 256 + 256 + + + 64 + 128 + 3 + 3 + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 256 + 256 + + + + + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 256 + 256 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 256 + 256 + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 128 + 128 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 64 + 64 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 128 + 128 + + + + + 1 + 32 + 128 + 128 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 128 + 128 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 256 + 256 + + + + + 1 + 32 + 256 + 256 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 256 + 256 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 256 + 256 + + + + + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 256 + 256 + + + + + 1 + 64 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + + 1 + 64 + 256 + 256 + + + + + + + + 1 + 64 + 256 + 256 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 64 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 64 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 64 + 256 + 256 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 64 + 256 + 256 + + + 2 + + + 2 + + + 2 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 512 + 512 + + + + + 1 + 128 + 512 + 512 + + + + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 128 + 3 + 3 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 128 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 128 + 3 + 3 + + + + + + + + 1 + 128 + 512 + 512 + + + 64 + 128 + 3 + 3 + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 512 + 512 + + + + + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 64 + 3 + 3 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 64 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 512 + 512 + + + 16 + 64 + 3 + 3 + + + + + 1 + 16 + 512 + 512 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 512 + 512 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 512 + 512 + + + + + + + 1 + 16 + 512 + 512 + + + + + 1 + 16 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + 1 + 16 + 512 + 512 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 256 + 256 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 256 + 256 + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 128 + 128 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 64 + 64 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 32 + 32 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 16 + 3 + 3 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 16 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 16 + 16 + + + 16 + 16 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 16 + 16 + + + + + 1 + 32 + 16 + 16 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 16 + 16 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 16 + 16 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 16 + 16 + + + + + + + 1 + 16 + 16 + 16 + + + + + 1 + 16 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + + 1 + 16 + 16 + 16 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 32 + 32 + + + + + 1 + 32 + 32 + 32 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 32 + 32 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 32 + 32 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 32 + 32 + + + + + + + 1 + 16 + 32 + 32 + + + + + 1 + 16 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + + 1 + 16 + 32 + 32 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 64 + 64 + + + + + 1 + 32 + 64 + 64 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 64 + 64 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 64 + 64 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 64 + 64 + + + + + + + 1 + 16 + 64 + 64 + + + + + 1 + 16 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + + 1 + 16 + 64 + 64 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 128 + 128 + + + + + 1 + 32 + 128 + 128 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 128 + 128 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 128 + 128 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 128 + 128 + + + + + + + 1 + 16 + 128 + 128 + + + + + 1 + 16 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + + 1 + 16 + 128 + 128 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 128 + 128 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 128 + 128 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 256 + 256 + + + + + 1 + 32 + 256 + 256 + + + + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 32 + 3 + 3 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 16 + 1 + 1 + 1 + + + + + + + + 16 + 32 + 3 + 3 + + + 16 + 1 + 1 + 1 + + + + + 16 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 256 + 256 + + + 16 + 32 + 3 + 3 + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 256 + 256 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 256 + 256 + + + + + + + 1 + 16 + 256 + 256 + + + + + 1 + 16 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + + 1 + 16 + 256 + 256 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 16 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 16 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 16 + 256 + 256 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 16 + 256 + 256 + + + 2 + + + 2 + + + 2 + + + + + 1 + 16 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + + 1 + 16 + 512 + 512 + + + + + + + + 1 + 16 + 512 + 512 + + + 1 + 16 + 512 + 512 + + + + + 1 + 32 + 512 + 512 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 64 + 1 + 1 + 1 + + + + + + + + 64 + 32 + 3 + 3 + + + 64 + 1 + 1 + 1 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 512 + 512 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 512 + 512 + + + + + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 512 + 512 + + + + + 1 + 64 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + + 1 + 64 + 512 + 512 + + + + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 3 + 3 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 512 + 512 + + + 1 + 64 + 3 + 3 + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 3 + 3 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 256 + 256 + + + 1 + 64 + 3 + 3 + + + + + 1 + 1 + 256 + 256 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 256 + 256 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 256 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 256 + 256 + + + + + + + + + 1 + 1 + 256 + 256 + + + + + + + + 1 + 1 + 256 + 256 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 1 + 256 + 256 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 1 + 256 + 256 + + + 2 + + + 2 + + + 2 + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 3 + 3 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 128 + 128 + + + 1 + 64 + 3 + 3 + + + + + 1 + 1 + 128 + 128 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 128 + 128 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 128 + 128 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 128 + 128 + + + + + + + + + 1 + 1 + 128 + 128 + + + + + + + + 1 + 1 + 128 + 128 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 1 + 128 + 128 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 1 + 128 + 128 + + + 2 + + + 2 + + + 2 + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 3 + 3 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 64 + 64 + + + 1 + 64 + 3 + 3 + + + + + 1 + 1 + 64 + 64 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 64 + 64 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 64 + 64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 64 + 64 + + + + + + + + + 1 + 1 + 64 + 64 + + + + + + + + 1 + 1 + 64 + 64 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 1 + 64 + 64 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 1 + 64 + 64 + + + 2 + + + 2 + + + 2 + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 3 + 3 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 32 + 32 + + + 1 + 64 + 3 + 3 + + + + + 1 + 1 + 32 + 32 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 32 + 32 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 32 + 32 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 32 + 32 + + + + + + + + + 1 + 1 + 32 + 32 + + + + + + + + 1 + 1 + 32 + 32 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 1 + 32 + 32 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 1 + 32 + 32 + + + 2 + + + 2 + + + 2 + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 3 + 3 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 64 + 3 + 3 + + + 1 + 1 + 1 + 1 + + + + + 1 + 64 + 3 + 3 + + + + + + + + 1 + 64 + 16 + 16 + + + 1 + 64 + 3 + 3 + + + + + 1 + 1 + 16 + 16 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 16 + 16 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 16 + 16 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 16 + 16 + + + + + + + + + 1 + 1 + 16 + 16 + + + + + + + + 1 + 1 + 16 + 16 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + + + 4 + + + + + + + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 1 + + + + + + + + 1 + + + + + 1 + + + + + + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + 2 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 4 + + + + + 4 + + + + + + + + 1 + 1 + 16 + 16 + + + + + 4 + + + + + + + + 4 + + + + + 4 + + + + + + + + 4 + + + 4 + + + + + 4 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + + + 4 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 1 + + + + + + + + 4 + + + 1 + + + 1 + + + 1 + + + + + 2 + + + + + + + + 2 + + + + + + + + 1 + 1 + 16 + 16 + + + 2 + + + 2 + + + 2 + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 512 + 512 + + + + + 1 + 6 + 512 + 512 + + + + + + + + 1 + 6 + 1 + 1 + + + + + + + + 1 + 6 + 1 + 1 + + + + + 1 + 6 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 6 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 6 + 1 + 1 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 6 + 1 + 1 + + + 1 + 1 + 1 + 1 + + + + + 1 + 6 + 1 + 1 + + + + + + + + 1 + 6 + 512 + 512 + + + 1 + 6 + 1 + 1 + + + + + 1 + 1 + 512 + 512 + + + + + + + + 1 + 1 + 1 + 1 + + + + + + + + 1 + 1 + 512 + 512 + + + 1 + 1 + 1 + 1 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + 1 + 1 + 512 + 512 + + + + + + + 1 + 1 + 512 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_3/openvino_notebooks/301-tensorflow-training-openvino.ipynb b/session_3/openvino_notebooks/301-tensorflow-training-openvino.ipynb new file mode 100644 index 0000000..bc72660 --- /dev/null +++ b/session_3/openvino_notebooks/301-tensorflow-training-openvino.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# From Training to Deployment with TensorFlow and OpenVINO™ " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "\n", + "# Copyright 2018 The TensorFlow Authors\n", + "#\n", + "# Modified for OpenVINO Notebooks" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KwQtSOz0VrVX" + }, + "source": [ + "This tutorial demonstrates how to train, convert, and deploy an image classification model with TensorFlow and OpenVINO. This particular notebook shows the process where we perform the inference step on the freshly trained model that is converted to OpenVINO IR with Model Optimizer. For faster inference speed on the model created in this notebook, check out the [Post-Training Quantization with TensorFlow Classification Model](./301-tensorflow-training-openvino-pot.ipynb) notebook.\n", + "\n", + "\n", + "This training code comprises the official [TensorFlow Image Classification Tutorial](https://www.tensorflow.org/tutorials/images/classification) in its entirety.\n", + "\n", + "The **flower_ir.bin** and **flower_ir.xml** (pre-trained models) can be obtained by executing the code with 'Runtime->Run All' or the Ctrl+F9 command." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TensorFlow Image Classification Training" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gN7G9GFmVrVY" + }, + "source": [ + "The first part of the tutorial shows how to classify images of flowers (based on the TensorFlow's official tutorial). It creates an image classifier using a `keras.Sequential` model, and loads data using `preprocessing.image_dataset_from_directory`. You will gain practical experience with the following concepts:\n", + "\n", + "* Efficiently loading a dataset off disk.\n", + "* Identifying overfitting and applying techniques to mitigate it, including data augmentation and Dropout.\n", + "\n", + "This tutorial follows a basic machine learning workflow:\n", + "\n", + "1. Examine and understand data\n", + "2. Build an input pipeline\n", + "3. Build the model\n", + "4. Train the model\n", + "5. Test the model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zF9uvbXNVrVY" + }, + "source": [ + "## Import TensorFlow and Other Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "L1WtoaOHVrVh" + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "import PIL\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from PIL import Image\n", + "from openvino.runtime import Core\n", + "from openvino.tools.mo import mo_tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "from tensorflow.keras.models import Sequential\n", + "\n", + "sys.path.append(\"../utils\")\n", + "from notebook_utils import download_file" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UZZI6lNkVrVm" + }, + "source": [ + "## Download and Explore the Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DPHx8-t-VrVo" + }, + "source": [ + "This tutorial uses a dataset of about 3,700 photos of flowers. The dataset contains 5 sub-directories, one per class:\n", + "\n", + "```\n", + "flower_photo/\n", + " daisy/\n", + " dandelion/\n", + " roses/\n", + " sunflowers/\n", + " tulips/\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "57CcilYSG0zv" + }, + "outputs": [], + "source": [ + "import pathlib\n", + "dataset_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\"\n", + "data_dir = tf.keras.utils.get_file('flower_photos', origin=dataset_url, untar=True)\n", + "data_dir = pathlib.Path(data_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VpmywIlsVrVx" + }, + "source": [ + "After downloading, you should now have a copy of the dataset available. There are 3,670 total images:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SbtTDYhOHZb6" + }, + "outputs": [], + "source": [ + "image_count = len(list(data_dir.glob('*/*.jpg')))\n", + "print(image_count)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PVmwkOSdHZ5A" + }, + "source": [ + "Here are some roses:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "N1loMlbYHeiJ" + }, + "outputs": [], + "source": [ + "roses = list(data_dir.glob('roses/*'))\n", + "PIL.Image.open(str(roses[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RQbZBOTLHiUP" + }, + "outputs": [], + "source": [ + "PIL.Image.open(str(roses[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DGEqiBbRHnyI" + }, + "source": [ + "And some tulips:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HyQkfPGdHilw" + }, + "outputs": [], + "source": [ + "tulips = list(data_dir.glob('tulips/*'))\n", + "PIL.Image.open(str(tulips[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wtlhWJPAHivf" + }, + "outputs": [], + "source": [ + "PIL.Image.open(str(tulips[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gIjgz7_JIo_m" + }, + "source": [ + "## Load Using keras.preprocessing\n", + "\n", + "Let's load these images off disk using the helpful [image_dataset_from_directory](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image_dataset_from_directory) utility. This will take you from a directory of images on disk to a `tf.data.Dataset` in just a couple lines of code. If you like, you can also write your own data loading code from scratch by visiting the [load images](https://www.tensorflow.org/tutorials/load_data/images) tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xyDNn9MbIzfT" + }, + "source": [ + "## Create a Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "anqiK_AGI086" + }, + "source": [ + "Define some parameters for the loader:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "H74l2DoDI2XD" + }, + "outputs": [], + "source": [ + "batch_size = 32\n", + "img_height = 180\n", + "img_width = 180" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pFBhRrrEI49z" + }, + "source": [ + "It's good practice to use a validation split when developing your model. Let's use 80% of the images for training, and 20% for validation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "fIR0kRZiI_AT" + }, + "outputs": [], + "source": [ + "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " data_dir,\n", + " validation_split=0.2,\n", + " subset=\"training\",\n", + " seed=123,\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iscU3UoVJBXj" + }, + "outputs": [], + "source": [ + "val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " data_dir,\n", + " validation_split=0.2,\n", + " subset=\"validation\",\n", + " seed=123,\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WLQULyAvJC3X" + }, + "source": [ + "You can find the class names in the `class_names` attribute on these datasets. These correspond to the directory names in alphabetical order." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ZHAxkHX5JD3k" + }, + "outputs": [], + "source": [ + "class_names = train_ds.class_names\n", + "print(class_names)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_uoVvxSLJW9m" + }, + "source": [ + "## Visualize the Data\n", + "\n", + "Here are the first 9 images from the training dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wBmEA9c0JYes" + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images, labels in train_ds.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i].numpy().astype(\"uint8\"))\n", + " plt.title(class_names[labels[i]])\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5M6BXtXFJdW0" + }, + "source": [ + "You will train a model using these datasets by passing them to `model.fit` in a moment. If you like, you can also manually iterate over the dataset and retrieve batches of images:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2-MfMoenJi8s" + }, + "outputs": [], + "source": [ + "for image_batch, labels_batch in train_ds:\n", + " print(image_batch.shape)\n", + " print(labels_batch.shape)\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wj4FrKxxJkoW" + }, + "source": [ + "The `image_batch` is a tensor of the shape `(32, 180, 180, 3)`. This is a batch of 32 images of shape `180x180x3` (the last dimension refers to color channels RGB). The `label_batch` is a tensor of the shape `(32,)`, these are corresponding labels to the 32 images. \n", + "\n", + "You can call `.numpy()` on the `image_batch` and `labels_batch` tensors to convert them to a `numpy.ndarray`.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4Dr0at41KcAU" + }, + "source": [ + "## Configure the Dataset for Performance\n", + "\n", + "Let's make sure to use buffered prefetching so you can yield data from disk without having I/O become blocking. These are two important methods you should use when loading data.\n", + "\n", + "`Dataset.cache()` keeps the images in memory after they're loaded off disk during the first epoch. This will ensure the dataset does not become a bottleneck while training your model. If your dataset is too large to fit into memory, you can also use this method to create a performant on-disk cache.\n", + "\n", + "`Dataset.prefetch()` overlaps data preprocessing and model execution while training. \n", + "\n", + "Interested readers can learn more about both methods, as well as how to cache data to disk in the [data performance guide](https://www.tensorflow.org/guide/data_performance#prefetching)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "nOjJSm7DKoZA" + }, + "outputs": [], + "source": [ + "# AUTOTUNE = tf.data.AUTOTUNE\n", + "AUTOTUNE = tf.data.experimental.AUTOTUNE\n", + "train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)\n", + "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8GUnmPF4JvEf" + }, + "source": [ + "## Standardize the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e56VXHMWJxYT" + }, + "source": [ + "The RGB channel values are in the `[0, 255]` range. This is not ideal for a neural network; in general you should seek to make your input values small. Here, you will standardize values to be in the `[0, 1]` range by using a Rescaling layer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PEYxo2CTJvY9" + }, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(1./255)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8aGpkwFaIw4i" + }, + "source": [ + "Note: The Keras Preprocessing utilities and layers introduced in this section are currently experimental and may change." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Bl4RmanbJ4g0" + }, + "source": [ + "There are two ways to use this layer. You can apply it to the dataset by calling map:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "X9o9ESaJJ502" + }, + "outputs": [], + "source": [ + "normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))\n", + "image_batch, labels_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]\n", + "# Notice the pixels values are now in `[0,1]`.\n", + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XWEOmRSBJ9J8" + }, + "source": [ + "Or, you can include the layer inside your model definition, which can simplify deployment. Let's use the second approach here.\n", + "\n", + "Note: you previously resized images using the `image_size` argument of `image_dataset_from_directory`. If you want to include the resizing logic in your model as well, you can use the [Resizing](https://www.tensorflow.org/api_docs/python/tf/keras/layers/experimental/preprocessing/Resizing) layer." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WcUTyDOPKucd" + }, + "source": [ + "## Create the Model\n", + "\n", + "The model consists of three convolution blocks with a max pool layer in each of them. There's a fully connected layer with 128 units on top of it that is activated by a `relu` activation function. This model has not been tuned for high accuracy, the goal of this tutorial is to show a standard approach. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QR6argA1K074" + }, + "outputs": [], + "source": [ + "num_classes = 5\n", + "\n", + "model = Sequential([\n", + " layers.experimental.preprocessing.Rescaling(1./255, input_shape=(img_height, img_width, 3)),\n", + " layers.Conv2D(16, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(32, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(64, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Flatten(),\n", + " layers.Dense(128, activation='relu'),\n", + " layers.Dense(num_classes)\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EaKFzz72Lqpg" + }, + "source": [ + "## Compile the Model\n", + "\n", + "For this tutorial, choose the `optimizers.Adam` optimizer and `losses.SparseCategoricalCrossentropy` loss function. To view training and validation accuracy for each training epoch, pass the `metrics` argument." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jloGNS1MLx3A" + }, + "outputs": [], + "source": [ + "model.compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aMJ4DnuJL55A" + }, + "source": [ + "## Model Summary\n", + "\n", + "View all the layers of the network using the model's `summary` method.\n", + "\n", + "> **NOTE:** This section is commented out for performance reasons. Please feel free to uncomment these to compare the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "llLYH-BXL7Xe" + }, + "outputs": [], + "source": [ + "# model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NiYHcbvaL9H-" + }, + "source": [ + "## Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5fWToCqYMErH" + }, + "outputs": [], + "source": [ + "# epochs=10\n", + "# history = model.fit(\n", + "# train_ds,\n", + "# validation_data=val_ds,\n", + "# epochs=epochs\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dFvOvmAmMK9w" + }, + "source": [ + "## Visualize Training Results\n", + "\n", + "Create plots of loss and accuracy on the training and validation sets." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jWnopEChMMCn" + }, + "outputs": [], + "source": [ + "# acc = history.history['accuracy']\n", + "# val_acc = history.history['val_accuracy']\n", + "\n", + "# loss = history.history['loss']\n", + "# val_loss = history.history['val_loss']\n", + "\n", + "# epochs_range = range(epochs)\n", + "\n", + "# plt.figure(figsize=(8, 8))\n", + "# plt.subplot(1, 2, 1)\n", + "# plt.plot(epochs_range, acc, label='Training Accuracy')\n", + "# plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n", + "# plt.legend(loc='lower right')\n", + "# plt.title('Training and Validation Accuracy')\n", + "\n", + "# plt.subplot(1, 2, 2)\n", + "# plt.plot(epochs_range, loss, label='Training Loss')\n", + "# plt.plot(epochs_range, val_loss, label='Validation Loss')\n", + "# plt.legend(loc='upper right')\n", + "# plt.title('Training and Validation Loss')\n", + "# plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hO_jT7HwMrEn" + }, + "source": [ + "As you can see from the plots, training accuracy and validation accuracy are off by large margin and the model has achieved only around 60% accuracy on the validation set.\n", + "\n", + "Let's look at what went wrong and try to increase the overall performance of the model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ixsz9XFfMxcu" + }, + "source": [ + "## Overfitting\n", + "\n", + "In the plots above, the training accuracy is increasing linearly over time, whereas validation accuracy stalls around 60% in the training process. Also, the difference in accuracy between training and validation accuracy is noticeable — a sign of [overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit).\n", + "\n", + "When there are a small number of training examples, the model sometimes learns from noises or unwanted details from training examples—to an extent that it negatively impacts the performance of the model on new examples. This phenomenon is known as overfitting. It means that the model will have a difficult time generalizing on a new dataset.\n", + "\n", + "There are multiple ways to fight overfitting in the training process. In this tutorial, you'll use *data augmentation* and add *Dropout* to your model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GxYwix81M2YO" + }, + "source": [ + "## Data Augmentation\n", + "\n", + "Overfitting generally occurs when there are a small number of training examples. [Data augmentation](https://www.tensorflow.org/tutorials/images/data_augmentation) takes the approach of generating additional training data from your existing examples by augmenting them using random transformations that yield believable-looking images. This helps expose the model to more aspects of the data and generalize better.\n", + "\n", + "You will implement data augmentation using the layers from `tf.keras.layers.experimental.preprocessing`. These can be included inside your model like other layers, and run on the GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9J80BAbIMs21" + }, + "outputs": [], + "source": [ + "data_augmentation = keras.Sequential(\n", + " [\n", + " layers.experimental.preprocessing.RandomFlip(\"horizontal\", \n", + " input_shape=(img_height, \n", + " img_width,\n", + " 3)),\n", + " layers.experimental.preprocessing.RandomRotation(0.1),\n", + " layers.experimental.preprocessing.RandomZoom(0.1),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PN4k1dK3S6eV" + }, + "source": [ + "Let's visualize what a few augmented examples look like by applying data augmentation to the same image several times:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7Z90k539S838" + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images, _ in train_ds.take(1):\n", + " for i in range(9):\n", + " augmented_images = data_augmentation(images)\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(augmented_images[0].numpy().astype(\"uint8\"))\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tsjXCBLYYNs5" + }, + "source": [ + "You will use data augmentation to train a model in a moment." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZeD3bXepYKXs" + }, + "source": [ + "## Dropout\n", + "\n", + "Another technique to reduce overfitting is to introduce [Dropout](https://developers.google.com/machine-learning/glossary#dropout_regularization) to the network, a form of *regularization*.\n", + "\n", + "When you apply Dropout to a layer it randomly drops out (by setting the activation to zero) a number of output units from the layer during the training process. Dropout takes a fractional number as its input value, in the form such as 0.1, 0.2, 0.4, etc. This means dropping out 10%, 20% or 40% of the output units randomly from the applied layer.\n", + "\n", + "Let's create a new neural network using `layers.Dropout`, then train it using augmented images." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2Zeg8zsqXCsm" + }, + "outputs": [], + "source": [ + "model = Sequential([\n", + " data_augmentation,\n", + " layers.experimental.preprocessing.Rescaling(1./255),\n", + " layers.Conv2D(16, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(32, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(64, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Dropout(0.2),\n", + " layers.Flatten(),\n", + " layers.Dense(128, activation='relu'),\n", + " layers.Dense(num_classes)\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L4nEcuqgZLbi" + }, + "source": [ + "## Compile and Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "EvyAINs9ZOmJ" + }, + "outputs": [], + "source": [ + "model.compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wWLkKoKjZSoC" + }, + "outputs": [], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PiAvrwo0tr6Z", + "tags": [], + "test_replace": { + "epochs = 15": "epochs = 1" + } + }, + "outputs": [], + "source": [ + "epochs = 15\n", + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=epochs\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Lkdl8VsBbZOu" + }, + "source": [ + "## Visualize Training Results\n", + "\n", + "After applying data augmentation and Dropout, there is less overfitting than before, and training and validation accuracy are closer aligned. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dduoLfKsZVIA" + }, + "outputs": [], + "source": [ + "acc = history.history['accuracy']\n", + "val_acc = history.history['val_accuracy']\n", + "\n", + "loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "epochs_range = range(epochs)\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(epochs_range, acc, label='Training Accuracy')\n", + "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n", + "plt.legend(loc='lower right')\n", + "plt.title('Training and Validation Accuracy')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(epochs_range, loss, label='Training Loss')\n", + "plt.plot(epochs_range, val_loss, label='Validation Loss')\n", + "plt.legend(loc='upper right')\n", + "plt.title('Training and Validation Loss')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dtv5VbaVb-3W" + }, + "source": [ + "## Predict on New Data\n", + "\n", + "Finally, let's use our model to classify an image that wasn't included in the training or validation sets.\n", + "\n", + "Note: Data augmentation and Dropout layers are inactive at inference time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dC40sRITBSsQ", + "tags": [] + }, + "outputs": [], + "source": [ + "sunflower_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg\"\n", + "sunflower_path = tf.keras.utils.get_file('Red_sunflower', origin=sunflower_url)\n", + "\n", + "img = keras.preprocessing.image.load_img(\n", + " sunflower_path, target_size=(img_height, img_width)\n", + ")\n", + "img_array = keras.preprocessing.image.img_to_array(img)\n", + "img_array = tf.expand_dims(img_array, 0) # Create a batch\n", + "\n", + "predictions = model.predict(img_array)\n", + "score = tf.nn.softmax(predictions[0])\n", + "\n", + "print(\n", + " \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n", + " .format(class_names[np.argmax(score)], 100 * np.max(score))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Save the TensorFlow Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#save the trained model - a new folder flower will be created\n", + "#and the file \"saved_model.pb\" is the pre-trained model\n", + "model_dir = \"model\"\n", + "model_fname = f\"{model_dir}/flower\"\n", + "model.save(model_fname)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convert the TensorFlow model with OpenVINO Model Optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The paths of the source and converted models\n", + "model_name = \"flower\"\n", + "model_path = Path(model_fname)\n", + "ir_data_type = \"FP16\"\n", + "ir_model_name = \"flower_ir\"\n", + "\n", + "# Get the path to the Model Optimizer script\n", + "\n", + "# Construct the command for Model Optimizer\n", + "mo_command = f\"\"\"mo \n", + " --saved_model_dir \"{model_fname}\"\n", + " --input_shape \"[1,180,180,3]\" \n", + " --data_type \"{ir_data_type}\" \n", + " --output_dir \"{model_fname}\"\n", + " --model_name \"{ir_model_name}\"\n", + " \"\"\"\n", + "mo_command = \" \".join(mo_command.split())\n", + "print(\"Model Optimizer command to convert TensorFlow to OpenVINO:\")\n", + "print(mo_command)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the Model Optimizer (overwrites the older model)\n", + "print(\"Exporting TensorFlow model to IR... This may take a few minutes.\")\n", + "mo_result = %sx $mo_command\n", + "print(\"\\n\".join(mo_result))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preprocessing Image Function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def pre_process_image(imagePath, img_height=180):\n", + " # Model input format\n", + " n, h, w, c = [1, img_height, img_height, 3]\n", + " image = Image.open(imagePath)\n", + " image = image.resize((h, w), resample=Image.BILINEAR)\n", + "\n", + " # Convert to array and change data layout from HWC to CHW\n", + " image = np.array(image)\n", + " input_image = image.reshape((n, h, w, c))\n", + "\n", + " return input_image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## OpenVINO Inference Engine Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class_names=[\"daisy\", \"dandelion\", \"roses\", \"sunflowers\", \"tulips\"]\n", + "\n", + "model_xml = f\"{model_fname}/flower_ir.xml\"\n", + "\n", + "# Load model\n", + "ie = Core()\n", + "model = ie.read_model(model=model_xml)\n", + "\n", + "# Neural Compute Stick\n", + "# compiled_model = ie.compile_model(model=model, device_name=\"MYRIAD\")\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")\n", + "\n", + "del model\n", + "\n", + "input_layer = compiled_model.input(0)\n", + "output_layer = compiled_model.output(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the Inference Step" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run inference on the input image...\n", + "inp_img_url = \"https://upload.wikimedia.org/wikipedia/commons/4/48/A_Close_Up_Photo_of_a_Dandelion.jpg\"\n", + "OUTPUT_DIR = \"output\"\n", + "inp_file_name = f\"A_Close_Up_Photo_of_a_Dandelion.jpg\"\n", + "file_path = Path(OUTPUT_DIR)/Path(inp_file_name)\n", + "\n", + "os.makedirs(OUTPUT_DIR, exist_ok=True)\n", + "\n", + "# Download the image\n", + "download_file(inp_img_url, inp_file_name, directory=OUTPUT_DIR)\n", + "\n", + "# Pre-process the image and get it ready for inference.\n", + "input_image = pre_process_image(file_path)\n", + "\n", + "print(input_image.shape)\n", + "print(input_layer.shape)\n", + "res = compiled_model([input_image])[output_layer]\n", + "\n", + "score = tf.nn.softmax(res[0])\n", + "\n", + "# Show the results\n", + "image = Image.open(file_path)\n", + "plt.imshow(image)\n", + "print(\n", + " \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n", + " .format(class_names[np.argmax(score)], 100 * np.max(score))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## The Next Steps\n", + "\n", + "This tutorial showed how to train a TensorFlow model, how to convert that model to OpenVINO's IR format, and how to do inference on the converted model. For faster inference speed, you can quantize the IR model. To see how to quantize this model with OpenVINO's [Post-Training Optimization Tool](https://docs.openvino.ai/2021.4/pot_README.html), check out the [Post-Training Quantization with TensorFlow Classification Model](./301-tensorflow-training-openvino-pot.ipynb) notebook." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "classification.ipynb", + "toc_visible": true + }, + "interpreter": { + "hash": "8e25c8ed6cc2cfe6c8620be5042bb64fac4c236f57496fb5eb68e9ea1795f1fe" + }, + "kernelspec": { + "display_name": "openvino_env", + "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.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/session_3/openvino_notebooks/model/flower/flower_ir.bin b/session_3/openvino_notebooks/model/flower/flower_ir.bin new file mode 100644 index 0000000..741899c Binary files /dev/null and b/session_3/openvino_notebooks/model/flower/flower_ir.bin differ diff --git a/session_3/openvino_notebooks/model/flower/flower_ir.mapping b/session_3/openvino_notebooks/model/flower/flower_ir.mapping new file mode 100644 index 0000000..4a77522 --- /dev/null +++ b/session_3/openvino_notebooks/model/flower/flower_ir.mapping @@ -0,0 +1,143 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_3/openvino_notebooks/model/flower/flower_ir.xml b/session_3/openvino_notebooks/model/flower/flower_ir.xml new file mode 100644 index 0000000..a973fbc --- /dev/null +++ b/session_3/openvino_notebooks/model/flower/flower_ir.xml @@ -0,0 +1,877 @@ + + + + + + + + + + + + 1 + 180 + 180 + 3 + + + + + + + + 4 + + + + + + + 1 + 180 + 180 + 3 + + + 4 + + + + + 1 + 3 + 180 + 180 + + + + + + + + 16 + 3 + 3 + 3 + + + + + + + + + + + 16 + 3 + 3 + 3 + + + + + 16 + 3 + 3 + 3 + + + + + + + + 1 + 3 + 180 + 180 + + + 16 + 3 + 3 + 3 + + + + + 1 + 16 + 180 + 180 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 180 + 180 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 180 + 180 + + + + + + + 1 + 16 + 180 + 180 + + + + + 1 + 16 + 180 + 180 + + + + + + + + 1 + 16 + 180 + 180 + + + + + 1 + 16 + 90 + 90 + + + 1 + 16 + 90 + 90 + + + + + + + + 32 + 16 + 3 + 3 + + + + + + + + + + + 32 + 16 + 3 + 3 + + + + + 32 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 90 + 90 + + + 32 + 16 + 3 + 3 + + + + + 1 + 32 + 90 + 90 + + + + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 90 + 90 + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 90 + 90 + + + + + + + 1 + 32 + 90 + 90 + + + + + 1 + 32 + 90 + 90 + + + + + + + + 1 + 32 + 90 + 90 + + + + + 1 + 32 + 45 + 45 + + + 1 + 32 + 45 + 45 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 45 + 45 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 45 + 45 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 45 + 45 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 45 + 45 + + + + + + + 1 + 64 + 45 + 45 + + + + + 1 + 64 + 45 + 45 + + + + + + + + 1 + 64 + 45 + 45 + + + + + 1 + 64 + 22 + 22 + + + 1 + 64 + 22 + 22 + + + + + + + + 4 + + + + + + + 1 + 64 + 22 + 22 + + + 4 + + + + + 1 + 22 + 22 + 64 + + + + + + + + 2 + + + + + + + + 1 + 22 + 22 + 64 + + + 2 + + + + + 1 + 30976 + + + + + + + + 128 + 30976 + + + + + + + + + + + 128 + 30976 + + + + + 128 + 30976 + + + + + + + + 1 + 30976 + + + 128 + 30976 + + + + + 1 + 128 + + + + + + + + 1 + 128 + + + + + + + + + + + 1 + 128 + + + + + 1 + 128 + + + + + + + + 1 + 128 + + + 1 + 128 + + + + + 1 + 128 + + + + + + + 1 + 128 + + + + + 1 + 128 + + + + + + + + 5 + 128 + + + + + + + + + + + 5 + 128 + + + + + 5 + 128 + + + + + + + + 1 + 128 + + + 5 + 128 + + + + + 1 + 5 + + + + + + + + 1 + 5 + + + + + + + + + + + 1 + 5 + + + + + 1 + 5 + + + + + + + + 1 + 5 + + + 1 + 5 + + + + + 1 + 5 + + + + + + + 1 + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_3/openvino_notebooks/model/flower/keras_metadata.pb b/session_3/openvino_notebooks/model/flower/keras_metadata.pb new file mode 100644 index 0000000..7db8e53 --- /dev/null +++ b/session_3/openvino_notebooks/model/flower/keras_metadata.pb @@ -0,0 +1,20 @@ + +droot"_tf_keras_sequential*d{"name": "sequential_4", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "must_restore_from_config": false, "class_name": "Sequential", "config": {"name": "sequential_4", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "sequential_2_input"}}, {"class_name": "Sequential", "config": {"name": "sequential_2", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_1_input"}}, {"class_name": "RandomFlip", "config": {"name": "random_flip_1", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}}, {"class_name": "RandomRotation", "config": {"name": "random_rotation_1", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}, {"class_name": "RandomZoom", "config": {"name": "random_zoom_1", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}]}}, {"class_name": "Rescaling", "config": {"name": "rescaling_3", "trainable": true, "dtype": "float32", "scale": 0.00392156862745098, "offset": 0.0}}, {"class_name": "Conv2D", "config": {"name": "conv2d_6", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_6", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}}, {"class_name": "Conv2D", "config": {"name": "conv2d_7", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_7", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}}, {"class_name": "Conv2D", "config": {"name": "conv2d_8", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_8", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}}, {"class_name": "Dropout", "config": {"name": "dropout_1", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}}, {"class_name": "Flatten", "config": {"name": "flatten_2", "trainable": true, "dtype": "float32", "data_format": "channels_last"}}, {"class_name": "Dense", "config": {"name": "dense_4", "trainable": true, "dtype": "float32", "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Dense", "config": {"name": "dense_5", "trainable": true, "dtype": "float32", "units": 5, "activation": "linear", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}]}, "shared_object_id": 27, "input_spec": [{"class_name": "InputSpec", "config": {"dtype": null, "shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}}], "build_input_shape": {"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "is_graph_network": true, "full_save_spec": {"class_name": "__tuple__", "items": [[{"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "sequential_2_input"]}], {}]}, "save_spec": {"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "sequential_2_input"]}, "keras_version": "2.9.0", "backend": "tensorflow", "model_config": {"class_name": "Sequential", "config": {"name": "sequential_4", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "sequential_2_input"}, "shared_object_id": 0}, {"class_name": "Sequential", "config": {"name": "sequential_2", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_1_input"}}, {"class_name": "RandomFlip", "config": {"name": "random_flip_1", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}}, {"class_name": "RandomRotation", "config": {"name": "random_rotation_1", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}, {"class_name": "RandomZoom", "config": {"name": "random_zoom_1", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}]}, "shared_object_id": 5}, {"class_name": "Rescaling", "config": {"name": "rescaling_3", "trainable": true, "dtype": "float32", "scale": 0.00392156862745098, "offset": 0.0}, "shared_object_id": 6}, {"class_name": "Conv2D", "config": {"name": "conv2d_6", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 7}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 8}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 9}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_6", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 10}, {"class_name": "Conv2D", "config": {"name": "conv2d_7", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 11}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 12}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 13}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_7", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 14}, {"class_name": "Conv2D", "config": {"name": "conv2d_8", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 15}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 16}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 17}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_8", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 18}, {"class_name": "Dropout", "config": {"name": "dropout_1", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "shared_object_id": 19}, {"class_name": "Flatten", "config": {"name": "flatten_2", "trainable": true, "dtype": "float32", "data_format": "channels_last"}, "shared_object_id": 20}, {"class_name": "Dense", "config": {"name": "dense_4", "trainable": true, "dtype": "float32", "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 21}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 22}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 23}, {"class_name": "Dense", "config": {"name": "dense_5", "trainable": true, "dtype": "float32", "units": 5, "activation": "linear", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 24}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 25}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 26}]}}, "training_config": {"loss": {"class_name": "SparseCategoricalCrossentropy", "config": {"reduction": "auto", "name": "sparse_categorical_crossentropy", "from_logits": true}, "shared_object_id": 29}, "metrics": [[{"class_name": "MeanMetricWrapper", "config": {"name": "accuracy", "dtype": "float32", "fn": "sparse_categorical_accuracy"}, "shared_object_id": 30}]], "weighted_metrics": null, "loss_weights": null, "optimizer_config": {"class_name": "Adam", "config": {"name": "Adam", "learning_rate": 0.0010000000474974513, "decay": 0.0, "beta_1": 0.8999999761581421, "beta_2": 0.9990000128746033, "epsilon": 1e-07, "amsgrad": false}}}}2 + root.layer-0"_tf_keras_sequential*{"name": "sequential_2", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "must_restore_from_config": false, "class_name": "Sequential", "config": {"name": "sequential_2", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_1_input"}}, {"class_name": "RandomFlip", "config": {"name": "random_flip_1", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}}, {"class_name": "RandomRotation", "config": {"name": "random_rotation_1", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}, {"class_name": "RandomZoom", "config": {"name": "random_zoom_1", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}]}, "shared_object_id": 5, "input_spec": [{"class_name": "InputSpec", "config": {"dtype": null, "shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}}], "build_input_shape": {"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "is_graph_network": true, "full_save_spec": {"class_name": "__tuple__", "items": [[{"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "random_flip_1_input"]}], {}]}, "save_spec": {"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "random_flip_1_input"]}, "keras_version": "2.9.0", "backend": "tensorflow", "model_config": {"class_name": "Sequential", "config": {"name": "sequential_2", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_1_input"}, "shared_object_id": 1}, {"class_name": "RandomFlip", "config": {"name": "random_flip_1", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}, "shared_object_id": 2}, {"class_name": "RandomRotation", "config": {"name": "random_rotation_1", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 3}, {"class_name": "RandomZoom", "config": {"name": "random_zoom_1", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 4}]}}}2 + root.layer-1"_tf_keras_layer*{"name": "rescaling_3", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Rescaling", "config": {"name": "rescaling_3", "trainable": true, "dtype": "float32", "scale": 0.00392156862745098, "offset": 0.0}, "shared_object_id": 6}2 + root.layer_with_weights-0"_tf_keras_layer* {"name": "conv2d_6", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Conv2D", "config": {"name": "conv2d_6", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 7}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 8}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 9, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 4, "axes": {"-1": 3}}, "shared_object_id": 32}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 180, 180, 3]}}2 + root.layer-3"_tf_keras_layer*{"name": "max_pooling2d_6", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_6", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 10, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}, "shared_object_id": 33}}2 + root.layer_with_weights-1"_tf_keras_layer* {"name": "conv2d_7", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Conv2D", "config": {"name": "conv2d_7", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 11}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 12}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 13, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 4, "axes": {"-1": 16}}, "shared_object_id": 34}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 90, 90, 16]}}2 + root.layer-5"_tf_keras_layer*{"name": "max_pooling2d_7", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_7", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 14, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}, "shared_object_id": 35}}2 + root.layer_with_weights-2"_tf_keras_layer* {"name": "conv2d_8", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Conv2D", "config": {"name": "conv2d_8", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 15}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 16}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 17, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 4, "axes": {"-1": 32}}, "shared_object_id": 36}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 45, 45, 32]}}2 + root.layer-7"_tf_keras_layer*{"name": "max_pooling2d_8", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_8", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 18, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}, "shared_object_id": 37}}2 +  root.layer-8"_tf_keras_layer*{"name": "dropout_1", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Dropout", "config": {"name": "dropout_1", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "shared_object_id": 19, "build_input_shape": {"class_name": "TensorShape", "items": [null, 22, 22, 64]}}2 + + root.layer-9"_tf_keras_layer*{"name": "flatten_2", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Flatten", "config": {"name": "flatten_2", "trainable": true, "dtype": "float32", "data_format": "channels_last"}, "shared_object_id": 20, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 1, "axes": {}}, "shared_object_id": 38}}2 + root.layer_with_weights-3"_tf_keras_layer*{"name": "dense_4", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Dense", "config": {"name": "dense_4", "trainable": true, "dtype": "float32", "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 21}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 22}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 23, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 2, "axes": {"-1": 30976}}, "shared_object_id": 39}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 30976]}}2 + root.layer_with_weights-4"_tf_keras_layer*{"name": "dense_5", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Dense", "config": {"name": "dense_5", "trainable": true, "dtype": "float32", "units": 5, "activation": "linear", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 24}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 25}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 26, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 2, "axes": {"-1": 128}}, "shared_object_id": 40}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 128]}}2 +root.layer-0.layer-0"_tf_keras_layer*{"name": "random_flip_1", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "stateful": false, "must_restore_from_config": false, "class_name": "RandomFlip", "config": {"name": "random_flip_1", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}, "shared_object_id": 2}2 +root.layer-0.layer-1"_tf_keras_layer*{"name": "random_rotation_1", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "RandomRotation", "config": {"name": "random_rotation_1", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 3}2 +root.layer-0.layer-2"_tf_keras_layer*{"name": "random_zoom_1", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "RandomZoom", "config": {"name": "random_zoom_1", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 4}2 +root.keras_api.metrics.0"_tf_keras_metric*{"class_name": "Mean", "name": "loss", "dtype": "float32", "config": {"name": "loss", "dtype": "float32"}, "shared_object_id": 41}2 +root.keras_api.metrics.1"_tf_keras_metric*{"class_name": "MeanMetricWrapper", "name": "accuracy", "dtype": "float32", "config": {"name": "accuracy", "dtype": "float32", "fn": "sparse_categorical_accuracy"}, "shared_object_id": 30}2 \ No newline at end of file diff --git a/session_3/openvino_notebooks/model/flower/saved_model.pb b/session_3/openvino_notebooks/model/flower/saved_model.pb new file mode 100644 index 0000000..3a19fde Binary files /dev/null and b/session_3/openvino_notebooks/model/flower/saved_model.pb differ diff --git a/session_3/openvino_notebooks/model/flower/variables/variables.data-00000-of-00001 b/session_3/openvino_notebooks/model/flower/variables/variables.data-00000-of-00001 new file mode 100644 index 0000000..9da02d3 Binary files /dev/null and b/session_3/openvino_notebooks/model/flower/variables/variables.data-00000-of-00001 differ diff --git a/session_3/openvino_notebooks/model/flower/variables/variables.index b/session_3/openvino_notebooks/model/flower/variables/variables.index new file mode 100644 index 0000000..f082e51 Binary files /dev/null and b/session_3/openvino_notebooks/model/flower/variables/variables.index differ diff --git a/session_3/openvino_notebooks/output/A_Close_Up_Photo_of_a_Dandelion.jpg b/session_3/openvino_notebooks/output/A_Close_Up_Photo_of_a_Dandelion.jpg new file mode 100644 index 0000000..918f458 Binary files /dev/null and b/session_3/openvino_notebooks/output/A_Close_Up_Photo_of_a_Dandelion.jpg differ diff --git a/session_3/openvino_notebooks/utils/async_pipeline.py b/session_3/openvino_notebooks/utils/async_pipeline.py new file mode 100644 index 0000000..20eb275 --- /dev/null +++ b/session_3/openvino_notebooks/utils/async_pipeline.py @@ -0,0 +1,154 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import logging +import threading +from collections import deque +from typing import Dict, Set +from pathlib import Path + + +def parse_devices(device_string): + colon_position = device_string.find(':') + if colon_position != -1: + device_type = device_string[:colon_position] + if device_type == 'HETERO' or device_type == 'MULTI': + comma_separated_devices = device_string[colon_position + 1:] + devices = comma_separated_devices.split(',') + for device in devices: + parenthesis_position = device.find(':') + if parenthesis_position != -1: + device = device[:parenthesis_position] + return devices + return (device_string,) + + +def parse_value_per_device(devices: Set[str], values_string: str)-> Dict[str, int]: + """Format: :,: or just """ + values_string_upper = values_string.upper() + result = {} + device_value_strings = values_string_upper.split(',') + for device_value_string in device_value_strings: + device_value_list = device_value_string.split(':') + if len(device_value_list) == 2: + if device_value_list[0] in devices: + result[device_value_list[0]] = int(device_value_list[1]) + elif len(device_value_list) == 1 and device_value_list[0] != '': + for device in devices: + result[device] = int(device_value_list[0]) + elif device_value_list[0] != '': + raise RuntimeError(f'Unknown string format: {values_string}') + return result + + +def get_user_config(flags_d: str, flags_nstreams: str, flags_nthreads: int)-> Dict[str, str]: + config = {} + + devices = set(parse_devices(flags_d)) + + device_nstreams = parse_value_per_device(devices, flags_nstreams) + for device in devices: + if device == 'CPU': # CPU supports a few special performance-oriented keys + # limit threading for CPU portion of inference + if flags_nthreads: + config['CPU_THREADS_NUM'] = str(flags_nthreads) + + config['CPU_BIND_THREAD'] = 'NO' + + # for CPU execution, more throughput-oriented execution via streams + config['CPU_THROUGHPUT_STREAMS'] = str(device_nstreams[device]) \ + if device in device_nstreams else 'CPU_THROUGHPUT_AUTO' + elif device == 'GPU': + config['GPU_THROUGHPUT_STREAMS'] = str(device_nstreams[device]) \ + if device in device_nstreams else 'GPU_THROUGHPUT_AUTO' + if 'MULTI' in flags_d and 'CPU' in devices: + # multi-device execution with the CPU + GPU performs best with GPU throttling hint, + # which releases another CPU thread (that is otherwise used by the GPU driver for active polling) + config['GPU_PLUGIN_THROTTLE'] = '1' + return config + + +class AsyncPipeline: + def __init__(self, ie, model, plugin_config, device='CPU', max_num_requests=0): + cache_path = Path("model_cache") + cache_path.mkdir(exist_ok=True) + # Enable model cachine for GPU devices + if "GPU" in device and "GPU" in ie.available_devices: + ie.set_config({"CACHE_DIR": str(cache_path)}, device_name="GPU") + + self.model = model + self.logger = logging.getLogger() + + self.logger.info('Loading network to {} plugin...'.format(device)) + self.exec_net = ie.load_network(network=self.model.net, device_name=device, + config=plugin_config, num_requests=max_num_requests) + if max_num_requests == 0: + # ExecutableNetwork doesn't allow creation of additional InferRequests. Reload ExecutableNetwork + # +1 to use it as a buffer of the pipeline + self.exec_net = ie.load_network(network=self.model.net, device_name=device, + config=plugin_config, num_requests=len(self.exec_net.requests) + 1) + + self.empty_requests = deque(self.exec_net.requests) + self.completed_request_results = {} + self.callback_exceptions = {} + self.event = threading.Event() + + def inference_completion_callback(self, status, callback_args): + try: + request, id, meta, preprocessing_meta = callback_args + if status != 0: + raise RuntimeError('Infer Request has returned status code {}'.format(status)) + raw_outputs = {key: blob.buffer for key, blob in request.output_blobs.items()} + self.completed_request_results[id] = (raw_outputs, meta, preprocessing_meta) + self.empty_requests.append(request) + except Exception as e: + self.callback_exceptions.append(e) + self.event.set() + + def submit_data(self, inputs, id, meta): + request = self.empty_requests.popleft() + if len(self.empty_requests) == 0: + self.event.clear() + inputs, preprocessing_meta = self.model.preprocess(inputs) + request.set_completion_callback(py_callback=self.inference_completion_callback, + py_data=(request, id, meta, preprocessing_meta)) + request.async_infer(inputs=inputs) + + def get_raw_result(self, id): + if id in self.completed_request_results: + return self.completed_request_results.pop(id) + return None + + def get_result(self, id): + result = self.get_raw_result(id) + if result: + raw_result, meta, preprocess_meta = result + return self.model.postprocess(raw_result, preprocess_meta), meta + return None + + def is_ready(self): + return len(self.empty_requests) != 0 + + def has_completed_request(self): + return len(self.completed_request_results) != 0 + + def await_all(self): + for request in self.exec_net.requests: + request.wait() + + def await_any(self): + if len(self.empty_requests) == 0: + self.event.wait() diff --git a/session_3/openvino_notebooks/utils/notebook_utils.ipynb b/session_3/openvino_notebooks/utils/notebook_utils.ipynb new file mode 100644 index 0000000..deaec04 --- /dev/null +++ b/session_3/openvino_notebooks/utils/notebook_utils.ipynb @@ -0,0 +1,1371 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e0ae5969", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "# Notebook Utils\n", + "\n", + "This notebook contains helper functions and classes for use with OpenVINO™ Notebooks. The code is synchronized with the `notebook_utils.py` file in the same directory as this notebook.\n", + "\n", + "There are five categories:\n", + "\n", + "- [Files](#Files)\n", + "- [Images](#Images)\n", + "- [Videos](#Videos)\n", + "- [Visualization](#Visualization)\n", + "- [OpenVINO Tools](#OpenVINO-Tools)\n", + "- [Checks and Alerts](#Checks-and-Alerts)\n", + "\n", + "Each category contains a test cell that also shows how to use the functions in the section. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "610d8c96", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import shutil\n", + "import socket\n", + "import threading\n", + "import time\n", + "import urllib\n", + "import urllib.parse\n", + "import urllib.request\n", + "from os import PathLike\n", + "from pathlib import Path\n", + "from typing import Callable, List, NamedTuple, Optional, Tuple\n", + "\n", + "import cv2\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import openvino.inference_engine\n", + "from async_pipeline import AsyncPipeline\n", + "from IPython.display import HTML, Image, Markdown, clear_output, display\n", + "from matplotlib.lines import Line2D\n", + "from models import model\n", + "from openvino.inference_engine import IECore\n", + "from tqdm.notebook import tqdm_notebook" + ] + }, + { + "cell_type": "markdown", + "id": "9e8b4817", + "metadata": {}, + "source": [ + "## Files\n", + "\n", + "Load an image, download a file, download an OpenVINO IR model, and create a progress bar to show download progress." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1584d210", + "metadata": {}, + "outputs": [], + "source": [ + "def load_image(path: str) -> np.ndarray:\n", + " \"\"\"\n", + " Loads an image from `path` and returns it as BGR numpy array. The `path` variable\n", + " should point to an image file, either a local filename or a url. The image is\n", + " not stored to the filesystem. Use the `download_file` function to download and\n", + " store an image.\n", + "\n", + " :param path: Local path name or URL to image.\n", + " :return: image as BGR numpy array\n", + " \"\"\"\n", + " if path.startswith(\"http\"):\n", + " # Set User-Agent to Mozilla because some websites block\n", + " # requests with User-Agent Python.\n", + " request = urllib.request.Request(path, headers={\"User-Agent\": \"Mozilla/5.0\"})\n", + " response = urllib.request.urlopen(request)\n", + " array = np.asarray(bytearray(response.read()), dtype=\"uint8\")\n", + " image = cv2.imdecode(array, -1) # Loads the image as BGR.\n", + " else:\n", + " image = cv2.imread(path)\n", + " return image\n", + "\n", + "\n", + "class DownloadProgressBar(tqdm_notebook):\n", + " \"\"\"\n", + " TQDM Progress bar for downloading files with urllib.request.urlretrieve\n", + " \"\"\"\n", + "\n", + " def update_to(self, block_num: int, block_size: int, total_size: int):\n", + " downloaded = block_num * block_size\n", + " if downloaded <= total_size:\n", + " self.update(downloaded - self.n)\n", + "\n", + "\n", + "def download_file(\n", + " url: PathLike,\n", + " filename: PathLike = None,\n", + " directory: PathLike = None,\n", + " show_progress: bool = True,\n", + " silent: bool = False,\n", + " timeout: int = 10,\n", + ") -> str:\n", + " \"\"\"\n", + " Download a file from a url and save it to the local filesystem. The file is saved to the\n", + " current directory by default, or to `directory` if specified. If a filename is not given,\n", + " the filename of the URL will be used.\n", + "\n", + " :param url: URL that points to the file to download.\n", + " :param filename: A name of the local file to save. It should point to the name of the file only,\n", + " not the full path. If set to None, the filename from the url will be used\n", + " :param directory: A directory to save the file to. It will be created if it does not exist\n", + " If set to None, the file will be saved to the current working directory.\n", + " :param show_progress: If set to True, shows an TQDM ProgressBar.\n", + " :param silent: If set to True, does not print a message if the file already exists.\n", + " :param timeout: number of seconds before cancelling the connection attempt\n", + " :return: path to downloaded file\n", + " \"\"\"\n", + " try:\n", + " opener = urllib.request.build_opener()\n", + " opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", + " urllib.request.install_opener(opener)\n", + " urlobject = urllib.request.urlopen(url, timeout=timeout)\n", + " if filename is None:\n", + " filename = urlobject.info().get_filename() or Path(urllib.parse.urlparse(url).path).name\n", + " except urllib.error.HTTPError as e:\n", + " raise Exception(f\"File downloading failed with error: {e.code} {e.msg}\") from None\n", + " except urllib.error.URLError as error:\n", + " if isinstance(error.reason, socket.timeout):\n", + " raise Exception(\n", + " \"Connection timed out. If you access the internet through a proxy server, \"\n", + " \"make sure the proxy is set in the shell from where you launched Jupyter. If your \"\n", + " \"internet connection is slow, you can call `download_file(url, timeout=30)` to \"\n", + " \"wait for 30 seconds before raising this error.\"\n", + " ) from None\n", + " else:\n", + " raise\n", + "\n", + " filename = Path(filename)\n", + " if len(filename.parts) > 1:\n", + " raise ValueError(\n", + " \"The `filename` parameter should refer to the name of the file, excluding the directory. \"\n", + " \"Use the `directory` parameter to specify a target directory for the downloaded file.\"\n", + " )\n", + "\n", + " # Create the directory if it does not exist, and add the directory to the filename.\n", + " if directory is not None:\n", + " directory = Path(directory)\n", + " directory.mkdir(parents=True, exist_ok=True)\n", + " filename = directory / Path(filename)\n", + "\n", + " # Download the file if it does not exist, or if it exists with an incorrect file size.\n", + " urlobject_size = int(urlobject.info().get(\"Content-Length\", 0))\n", + " if not filename.exists() or (os.stat(filename).st_size != urlobject_size):\n", + " progress_callback = DownloadProgressBar(\n", + " total=urlobject_size,\n", + " unit=\"B\",\n", + " unit_scale=True,\n", + " unit_divisor=1024,\n", + " desc=str(filename),\n", + " disable=not show_progress,\n", + " )\n", + " urllib.request.urlretrieve(url, filename, reporthook=progress_callback.update_to)\n", + " if os.stat(filename).st_size >= urlobject_size:\n", + " progress_callback.update(urlobject_size - progress_callback.n)\n", + " progress_callback.refresh()\n", + " else:\n", + " if not silent:\n", + " print(f\"'{filename}' already exists.\")\n", + " return filename.resolve()\n", + "\n", + "\n", + "def download_ir_model(model_xml_url: str, destination_folder: PathLike = None) -> PathLike:\n", + " \"\"\"\n", + " Download OpenVINO IR model from `model_xml_url`. Downloads xml and bin file of the model; the weights file is\n", + " assumed to exist at the same location and name as `model_xml_url` with a \".bin\" extension.\n", + "\n", + " :param model_xml_url: The URL to xml file of the model to download.\n", + " :param destination_folder: A directory where downloaded xml and bin files of the model are saved. If set to None, model\n", + " files are saved to the current directory.\n", + " :return: The path to downloaded xml file of the model.\n", + " \"\"\"\n", + " model_bin_url = model_xml_url[:-4] + \".bin\"\n", + " model_xml_path = download_file(model_xml_url, directory=destination_folder, show_progress=False)\n", + " download_file(model_bin_url, directory=destination_folder)\n", + " return model_xml_path" + ] + }, + { + "cell_type": "markdown", + "id": "407d4219", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test File Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa1a0ee0", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "model_url = \"https://github.com/openvinotoolkit/openvino_notebooks/raw/main/notebooks/002-openvino-api/model/segmentation.xml\"\n", + "download_ir_model(model_url, \"model\")\n", + "\n", + "assert os.path.exists(\"model/segmentation.xml\")\n", + "assert os.path.exists(\"model/segmentation.bin\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51392a8e", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "url = \"https://github.com/intel-iot-devkit/safety-gear-detector-python/raw/master/resources/Safety_Full_Hat_and_Vest.mp4\"\n", + "if os.path.exists(os.path.basename(url)):\n", + " os.remove(os.path.basename(url))\n", + "video_file = download_file(url)\n", + "print(video_file)\n", + "assert Path(video_file).exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46478651", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "url = \"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/README.md\"\n", + "filename = \"openvino_notebooks_readme.md\"\n", + "if os.path.exists(filename):\n", + " os.remove(filename)\n", + "readme_file = download_file(url, filename=filename)\n", + "print(readme_file)\n", + "assert Path(readme_file).exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d15056b5", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "url = \"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/README.md\"\n", + "filename = \"openvino_notebooks_readme.md\"\n", + "directory = \"temp\"\n", + "video_file = download_file(\n", + " url, filename=filename, directory=directory, show_progress=False, silent=True\n", + ")\n", + "print(readme_file)\n", + "assert Path(readme_file).exists()\n", + "shutil.rmtree(\"temp\")" + ] + }, + { + "cell_type": "markdown", + "id": "b6f5caa5", + "metadata": {}, + "source": [ + "## Images" + ] + }, + { + "cell_type": "markdown", + "id": "9c45916c", + "metadata": {}, + "source": [ + "### Convert Pixel Data\n", + "\n", + "Normalize image pixel values between 0 and 1, and convert images to `RGB` and `BGR`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4051c7ef", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_minmax(data):\n", + " \"\"\"\n", + " Normalizes the values in `data` between 0 and 1\n", + " \"\"\"\n", + " if data.max() == data.min():\n", + " raise ValueError(\n", + " \"Normalization is not possible because all elements of\"\n", + " f\"`data` have the same value: {data.max()}.\"\n", + " )\n", + " return (data - data.min()) / (data.max() - data.min())\n", + "\n", + "\n", + "def to_rgb(image_data: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " Convert image_data from BGR to RGB.\n", + " \"\"\"\n", + " return cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB)\n", + "\n", + "\n", + "def to_bgr(image_data: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " Convert image_data from RGB to BGR.\n", + " \"\"\"\n", + " return cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)" + ] + }, + { + "cell_type": "markdown", + "id": "6a2ec41b", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Data Conversion Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8ae28f4", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "test_array = np.random.randint(0, 255, (100, 100, 3))\n", + "normalized_array = normalize_minmax(test_array)\n", + "\n", + "assert normalized_array.min() == 0\n", + "assert normalized_array.max() == 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2922a67", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "bgr_array = np.ones((100, 100, 3), dtype=np.uint8)\n", + "bgr_array[:, :, 0] = 0\n", + "bgr_array[:, :, 1] = 1\n", + "bgr_array[:, :, 2] = 2\n", + "rgb_array = to_rgb(bgr_array)\n", + "\n", + "assert np.all(bgr_array[:, :, 0] == rgb_array[:, :, 2])\n", + "\n", + "bgr_array_converted = to_bgr(rgb_array)\n", + "assert np.all(bgr_array_converted == bgr_array)" + ] + }, + { + "cell_type": "markdown", + "id": "8e27e37e", + "metadata": {}, + "source": [ + "## Videos" + ] + }, + { + "cell_type": "markdown", + "id": "b134d512", + "metadata": {}, + "source": [ + "### Video Player\n", + "\n", + "A custom video player to fulfill FPS requirements. You can set target FPS and output size, flip the video horizontally or skip first N frames." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd5a3145", + "metadata": { + "pycharm": { + "name": "#%% \n" + } + }, + "outputs": [], + "source": [ + "class VideoPlayer:\n", + " \"\"\"\n", + " Custom video player to fulfill FPS requirements. You can set target FPS and output size,\n", + " flip the video horizontally or skip first N frames.\n", + "\n", + " :param source: Video source. It could be either camera device or video file.\n", + " :param size: Output frame size.\n", + " :param flip: Flip source horizontally.\n", + " :param fps: Target FPS.\n", + " :param skip_first_frames: Skip first N frames.\n", + " \"\"\"\n", + "\n", + " def __init__(self, source, size=None, flip=False, fps=None, skip_first_frames=0):\n", + " self.__cap = cv2.VideoCapture(source)\n", + " if not self.__cap.isOpened():\n", + " raise RuntimeError(\n", + " f\"Cannot open {'camera' if isinstance(source, int) else ''} {source}\"\n", + " )\n", + " # Skip first N frames.\n", + " self.__cap.set(cv2.CAP_PROP_POS_FRAMES, skip_first_frames)\n", + " # fps of input file\n", + " self.__input_fps = self.__cap.get(cv2.CAP_PROP_FPS)\n", + " if self.__input_fps <= 0:\n", + " self.__input_fps = 60\n", + " # target fps given by user\n", + " self.__output_fps = fps if fps is not None else self.__input_fps\n", + " self.__flip = flip\n", + " self.__size = None\n", + " self.__interpolation = None\n", + " if size is not None:\n", + " self.__size = size\n", + " # AREA better for shrinking, LINEAR better for enlarging\n", + " self.__interpolation = (\n", + " cv2.INTER_AREA\n", + " if size[0] < self.__cap.get(cv2.CAP_PROP_FRAME_WIDTH)\n", + " else cv2.INTER_LINEAR\n", + " )\n", + " # first frame\n", + " _, self.__frame = self.__cap.read()\n", + " self.__lock = threading.Lock()\n", + " self.__thread = None\n", + " self.__stop = False\n", + "\n", + " \"\"\"\n", + " Start playing.\n", + " \"\"\"\n", + "\n", + " def start(self):\n", + " self.__stop = False\n", + " self.__thread = threading.Thread(target=self.__run, daemon=True)\n", + " self.__thread.start()\n", + "\n", + " \"\"\"\n", + " Stop playing and release resources.\n", + " \"\"\"\n", + "\n", + " def stop(self):\n", + " self.__stop = True\n", + " if self.__thread is not None:\n", + " self.__thread.join()\n", + " self.__cap.release()\n", + "\n", + " def __run(self):\n", + " prev_time = 0\n", + " while not self.__stop:\n", + " t1 = time.time()\n", + " ret, frame = self.__cap.read()\n", + " if not ret:\n", + " break\n", + "\n", + " # Fulfill target fps.\n", + " if 1 / self.__output_fps < time.time() - prev_time:\n", + " prev_time = time.time()\n", + " # Replace by current frame.\n", + " with self.__lock:\n", + " self.__frame = frame\n", + "\n", + " t2 = time.time()\n", + " # time to wait [s] to fulfill input fps\n", + " wait_time = 1 / self.__input_fps - (t2 - t1)\n", + " # Wait until.\n", + " time.sleep(max(0, wait_time))\n", + "\n", + " self.__frame = None\n", + "\n", + " \"\"\"\n", + " Get current frame.\n", + " \"\"\"\n", + "\n", + " def next(self):\n", + " with self.__lock:\n", + " if self.__frame is None:\n", + " return None\n", + " # Need to copy frame, because it can be cached and reused if fps is low.\n", + " frame = self.__frame.copy()\n", + " if self.__size is not None:\n", + " frame = cv2.resize(frame, self.__size, interpolation=self.__interpolation)\n", + " if self.__flip:\n", + " frame = cv2.flip(frame, 1)\n", + " return frame" + ] + }, + { + "cell_type": "markdown", + "id": "8ab7b29e", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Video Player" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3b1fc3c", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "video = \"../201-vision-monodepth/data/Coco Walking in Berkeley.mp4\"\n", + "\n", + "player = VideoPlayer(video, fps=15, skip_first_frames=10)\n", + "player.start()\n", + "for i in range(50):\n", + " frame = player.next()\n", + " _, encoded_img = cv2.imencode(\".jpg\", frame, params=[cv2.IMWRITE_JPEG_QUALITY, 90])\n", + " img = Image(data=encoded_img)\n", + " clear_output(wait=True)\n", + " display(img)\n", + "\n", + "player.stop()\n", + "print(\"Finished\")" + ] + }, + { + "cell_type": "markdown", + "id": "b9c69891", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "id": "67182f4f", + "metadata": {}, + "source": [ + "### Segmentation\n", + "\n", + "Define a `SegmentationMap NamedTuple` that keeps the labels and colormap for a segmentation project/dataset. Create `CityScapesSegmentation` and `BinarySegmentation SegmentationMaps`. Create a function to convert a segmentation map to an `RGB` image with a `colormap`, and to show the segmentation result as an overlay over the original image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8c64d62", + "metadata": {}, + "outputs": [], + "source": [ + "class Label(NamedTuple):\n", + " index: int\n", + " color: Tuple\n", + " name: Optional[str] = None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "693bd276", + "metadata": {}, + "outputs": [], + "source": [ + "class SegmentationMap(NamedTuple):\n", + " labels: List\n", + "\n", + " def get_colormap(self):\n", + " return np.array([label.color for label in self.labels])\n", + "\n", + " def get_labels(self):\n", + " labelnames = [label.name for label in self.labels]\n", + " if any(labelnames):\n", + " return labelnames\n", + " else:\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd88c7ae", + "metadata": {}, + "outputs": [], + "source": [ + "cityscape_labels = [\n", + " Label(index=0, color=(128, 64, 128), name=\"road\"),\n", + " Label(index=1, color=(244, 35, 232), name=\"sidewalk\"),\n", + " Label(index=2, color=(70, 70, 70), name=\"building\"),\n", + " Label(index=3, color=(102, 102, 156), name=\"wall\"),\n", + " Label(index=4, color=(190, 153, 153), name=\"fence\"),\n", + " Label(index=5, color=(153, 153, 153), name=\"pole\"),\n", + " Label(index=6, color=(250, 170, 30), name=\"traffic light\"),\n", + " Label(index=7, color=(220, 220, 0), name=\"traffic sign\"),\n", + " Label(index=8, color=(107, 142, 35), name=\"vegetation\"),\n", + " Label(index=9, color=(152, 251, 152), name=\"terrain\"),\n", + " Label(index=10, color=(70, 130, 180), name=\"sky\"),\n", + " Label(index=11, color=(220, 20, 60), name=\"person\"),\n", + " Label(index=12, color=(255, 0, 0), name=\"rider\"),\n", + " Label(index=13, color=(0, 0, 142), name=\"car\"),\n", + " Label(index=14, color=(0, 0, 70), name=\"truck\"),\n", + " Label(index=15, color=(0, 60, 100), name=\"bus\"),\n", + " Label(index=16, color=(0, 80, 100), name=\"train\"),\n", + " Label(index=17, color=(0, 0, 230), name=\"motorcycle\"),\n", + " Label(index=18, color=(119, 11, 32), name=\"bicycle\"),\n", + " Label(index=19, color=(255, 255, 255), name=\"background\"),\n", + "]\n", + "\n", + "CityScapesSegmentation = SegmentationMap(cityscape_labels)\n", + "\n", + "binary_labels = [\n", + " Label(index=0, color=(255, 255, 255), name=\"background\"),\n", + " Label(index=1, color=(0, 0, 0), name=\"foreground\"),\n", + "]\n", + "\n", + "BinarySegmentation = SegmentationMap(binary_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0fa0b5dc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def segmentation_map_to_image(\n", + " result: np.ndarray, colormap: np.ndarray, remove_holes: bool = False\n", + ") -> np.ndarray:\n", + " \"\"\"\n", + " Convert network result of floating point numbers to an RGB image with\n", + " integer values from 0-255 by applying a colormap.\n", + "\n", + " :param result: A single network result after converting to pixel values in H,W or 1,H,W shape.\n", + " :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class.\n", + " :param remove_holes: If set to True, remove holes in the segmentation result.\n", + " :return: An RGB image where each pixel is an int8 value according to colormap.\n", + " \"\"\"\n", + " if len(result.shape) != 2 and result.shape[0] != 1:\n", + " raise ValueError(\n", + " f\"Expected result with shape (H,W) or (1,H,W), got result with shape {result.shape}\"\n", + " )\n", + "\n", + " if len(np.unique(result)) > colormap.shape[0]:\n", + " raise ValueError(\n", + " f\"Expected max {colormap[0]} classes in result, got {len(np.unique(result))} \"\n", + " \"different output values. Make sure to convert the network output to \"\n", + " \"pixel values before calling this function.\"\n", + " )\n", + " elif result.shape[0] == 1:\n", + " result = result.squeeze(0)\n", + "\n", + " result = result.astype(np.uint8)\n", + "\n", + " contour_mode = cv2.RETR_EXTERNAL if remove_holes else cv2.RETR_TREE\n", + " mask = np.zeros((result.shape[0], result.shape[1], 3), dtype=np.uint8)\n", + " for label_index, color in enumerate(colormap):\n", + " label_index_map = result == label_index\n", + " label_index_map = label_index_map.astype(np.uint8) * 255\n", + " contours, hierarchies = cv2.findContours(\n", + " label_index_map, contour_mode, cv2.CHAIN_APPROX_SIMPLE\n", + " )\n", + " cv2.drawContours(\n", + " mask,\n", + " contours,\n", + " contourIdx=-1,\n", + " color=color.tolist(),\n", + " thickness=cv2.FILLED,\n", + " )\n", + "\n", + " return mask\n", + "\n", + "\n", + "def segmentation_map_to_overlay(image, result, alpha, colormap, remove_holes=False) -> np.ndarray:\n", + " \"\"\"\n", + " Returns a new image where a segmentation mask (created with colormap) is overlayed on\n", + " the source image.\n", + "\n", + " :param image: Source image.\n", + " :param result: A single network result after converting to pixel values in H,W or 1,H,W shape.\n", + " :param alpha: Alpha transparency value for the overlay image.\n", + " :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class.\n", + " :param remove_holes: If set to True, remove holes in the segmentation result.\n", + " :return: An RGP image with segmentation mask overlayed on the source image.\n", + " \"\"\"\n", + " if len(image.shape) == 2:\n", + " image = np.repeat(np.expand_dims(image, -1), 3, 2)\n", + " mask = segmentation_map_to_image(result, colormap, remove_holes)\n", + " image_height, image_width = image.shape[:2]\n", + " mask = cv2.resize(src=mask, dsize=(image_width, image_height))\n", + " return cv2.addWeighted(mask, alpha, image, 1 - alpha, 0)" + ] + }, + { + "cell_type": "markdown", + "id": "72ab2c0c", + "metadata": {}, + "source": [ + "### Network Results\n", + "\n", + "Show network result image, optionally together with the source image and a legend with labels." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d162edd1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def viz_result_image(\n", + " result_image: np.ndarray,\n", + " source_image: np.ndarray = None,\n", + " source_title: str = None,\n", + " result_title: str = None,\n", + " labels: List[Label] = None,\n", + " resize: bool = False,\n", + " bgr_to_rgb: bool = False,\n", + " hide_axes: bool = False,\n", + ") -> matplotlib.figure.Figure:\n", + " \"\"\"\n", + " Show result image, optionally together with source images, and a legend with labels.\n", + "\n", + " :param result_image: Numpy array of RGB result image.\n", + " :param source_image: Numpy array of source image. If provided, this image will be shown\n", + " next to the result image. The 'source_image' is expected to be in RGB format.\n", + " Set `bgr_to_rgb` to True if `source_image` is in BGR format.\n", + " :param source_title: Title to display for the source image.\n", + " :param result_title: Title to display for the result image.\n", + " :param labels: List of labels. If provided, a legend will be shown with the given labels.\n", + " :param resize: If set to True, resize the result image to the same shape as the source image.\n", + " :param bgr_to_rgb: If set to True, convert the source image from BGR to RGB. Use this option if\n", + " `source_image` is a BGR image.\n", + " :param hide_axes: If set to True, do not show matplotlib axes.\n", + " :return: Matplotlib figure with the result image.\n", + " \"\"\"\n", + " if bgr_to_rgb:\n", + " source_image = to_rgb(source_image)\n", + " if resize:\n", + " result_image = cv2.resize(result_image, (source_image.shape[1], source_image.shape[0]))\n", + "\n", + " num_images = 1 if source_image is None else 2\n", + "\n", + " fig, ax = plt.subplots(1, num_images, figsize=(16, 8), squeeze=False)\n", + " if source_image is not None:\n", + " ax[0, 0].imshow(source_image)\n", + " ax[0, 0].set_title(source_title)\n", + "\n", + " ax[0, num_images - 1].imshow(result_image)\n", + " ax[0, num_images - 1].set_title(result_title)\n", + "\n", + " if hide_axes:\n", + " for a in ax.ravel():\n", + " a.axis(\"off\")\n", + " if labels:\n", + " colors = labels.get_colormap()\n", + " lines = [\n", + " Line2D(\n", + " [0],\n", + " [0],\n", + " color=[item / 255 for item in c.tolist()],\n", + " linewidth=3,\n", + " linestyle=\"-\",\n", + " )\n", + " for c in colors\n", + " ]\n", + " plt.legend(\n", + " lines,\n", + " labels.get_labels(),\n", + " bbox_to_anchor=(1, 1),\n", + " loc=\"upper left\",\n", + " prop={\"size\": 12},\n", + " )\n", + " plt.close(fig)\n", + " return fig" + ] + }, + { + "cell_type": "markdown", + "id": "a6f109c8-1b31-44ce-9c8e-6e52dd489994", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Visualization Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d300c70", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "testimage = np.zeros((100, 100, 3), dtype=np.uint8)\n", + "testimage[30:80, 30:80, :] = [0, 255, 0]\n", + "testimage[0:10, 0:10, :] = 100\n", + "testimage[40:60, 40:60, :] = 128\n", + "testimage[testimage == 0] = 128\n", + "\n", + "\n", + "testmask1 = np.zeros((testimage.shape[:2]))\n", + "testmask1[30:80, 30:80] = 1\n", + "testmask1[40:50, 40:50] = 0\n", + "testmask1[0:15, 0:10] = 2\n", + "\n", + "result_image_overlay = segmentation_map_to_overlay(\n", + " image=testimage,\n", + " result=testmask1,\n", + " alpha=0.6,\n", + " colormap=np.array([[0, 0, 0], [255, 0, 0], [255, 255, 0]]),\n", + ")\n", + "result_image = segmentation_map_to_image(testmask1, CityScapesSegmentation.get_colormap())\n", + "result_image_no_holes = segmentation_map_to_image(\n", + " testmask1, CityScapesSegmentation.get_colormap(), remove_holes=True\n", + ")\n", + "resized_result_image = cv2.resize(result_image, (50, 50))\n", + "overlay_result_image = segmentation_map_to_overlay(\n", + " testimage, testmask1, 0.6, CityScapesSegmentation.get_colormap(), remove_holes=False\n", + ")\n", + "\n", + "fig1 = viz_result_image(result_image, testimage)\n", + "fig2 = viz_result_image(result_image_no_holes, testimage, labels=CityScapesSegmentation)\n", + "fig3 = viz_result_image(\n", + " resized_result_image,\n", + " testimage,\n", + " source_title=\"Source Image\",\n", + " result_title=\"Resized Result Image\",\n", + " resize=True,\n", + ")\n", + "fig4 = viz_result_image(\n", + " overlay_result_image,\n", + " labels=CityScapesSegmentation,\n", + " result_title=\"Image with Result Overlay\",\n", + ")\n", + "\n", + "display(fig1, fig2, fig3, fig4)" + ] + }, + { + "cell_type": "markdown", + "id": "97885ed0-8dea-4511-8558-bf146f5ae9d9", + "metadata": {}, + "source": [ + "### Live Inference" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3cf6f55-3d43-467b-94ed-318e345a4d1c", + "metadata": {}, + "outputs": [], + "source": [ + "def showarray(frame: np.ndarray, display_handle=None):\n", + " \"\"\"\n", + " Display `frame` array. Replace information at `display_handle` with `frame`\n", + " encoded as jpeg image. The `frame` array is expected to have data in BGR order.\n", + "\n", + " Create a `display_handle` with: `display_handle = display(display_id=True)`\n", + " \"\"\"\n", + " _, frame = cv2.imencode(ext=\".jpeg\", img=frame)\n", + " if display_handle is None:\n", + " display_handle = display(Image(data=frame.tobytes()), display_id=True)\n", + " else:\n", + " display_handle.update(Image(data=frame.tobytes()))\n", + " return display_handle\n", + "\n", + "\n", + "def show_live_inference(\n", + " ie, image_paths: List, model: model.Model, device: str, reader: Optional[Callable] = None\n", + "):\n", + " \"\"\"\n", + " Do inference of images listed in `image_paths` on `model` on the given `device` and show\n", + " the results in real time in a Jupyter Notebook.\n", + "\n", + " :param image_paths: List of image filenames to load.\n", + " :param model: Model instance for inference.\n", + " :param device: Name of device to perform inference on. For example: \"CPU\".\n", + " :param reader: Image reader. Should return a numpy array with image data.\n", + " If set to None, `cv2.imread` will be used, with the `cv2.IMREAD_UNCHANGED` flag.\n", + " \"\"\"\n", + " display_handle = None\n", + " next_frame_id = 0\n", + " next_frame_id_to_show = 0\n", + "\n", + " input_layer = next(iter(model.net.input_info))\n", + "\n", + " # Create asynchronous pipeline and print time it takes to load the model.\n", + " load_start_time = time.perf_counter()\n", + " pipeline = AsyncPipeline(\n", + " ie=ie, model=model, plugin_config={}, device=device, max_num_requests=0\n", + " )\n", + " load_end_time = time.perf_counter()\n", + "\n", + " # Perform asynchronous inference.\n", + " start_time = time.perf_counter()\n", + "\n", + " while next_frame_id < len(image_paths) - 1:\n", + " results = pipeline.get_result(next_frame_id_to_show)\n", + "\n", + " if results:\n", + " # Show next result from async pipeline.\n", + " result, meta = results\n", + " display_handle = showarray(result, display_handle)\n", + " next_frame_id_to_show += 1\n", + " if pipeline.is_ready():\n", + " # Submit a new image to async pipeline.\n", + " image_path = image_paths[next_frame_id]\n", + " if reader is None:\n", + " image = cv2.imread(filename=str(image_path), flags=cv2.IMREAD_UNCHANGED)\n", + " else:\n", + " image = reader(str(image_path))\n", + " pipeline.submit_data(\n", + " inputs={input_layer: image}, id=next_frame_id, meta={\"frame\": image}\n", + " )\n", + " del image\n", + " next_frame_id += 1\n", + " else:\n", + " # If the pipeline is not ready yet and there are no results: wait.\n", + " pipeline.await_any()\n", + "\n", + " pipeline.await_all()\n", + "\n", + " # Show all frames that are in the pipeline after all images have been submitted.\n", + " while pipeline.has_completed_request():\n", + " results = pipeline.get_result(next_frame_id_to_show)\n", + " if results:\n", + " result, meta = results\n", + " display_handle = showarray(result, display_handle)\n", + " next_frame_id_to_show += 1\n", + "\n", + " end_time = time.perf_counter()\n", + " duration = end_time - start_time\n", + " fps = len(image_paths) / duration\n", + " print(f\"Loaded model to {device} in {load_end_time-load_start_time:.2f} seconds.\")\n", + " print(f\"Total time for {next_frame_id} frames: {duration:.2f} seconds, fps:{fps:.2f}\")\n", + "\n", + " del pipeline.exec_net\n", + " del pipeline" + ] + }, + { + "cell_type": "markdown", + "id": "45df4809-567b-4d3b-b947-d4a0ed981ce9", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "#### Test Live Inference" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e6be35b-de7b-47b7-8cd1-f6ef96e2d0cb", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "# Test binary segmentation\n", + "from models.custom_segmentation import SegmentationModel\n", + "\n", + "image_paths = sorted(list(Path(\"../111-detection-quantization/data\").glob(\"*.jpg\")))\n", + "\n", + "ie = IECore()\n", + "segmentation_model = SegmentationModel(\n", + " ie,\n", + " Path(\"model/segmentation.xml\"),\n", + " sigmoid=False,\n", + " colormap=np.array([[0, 0, 0], [0, 0, 255]]),\n", + " rgb=True,\n", + " rotate_and_flip=False,\n", + ")\n", + "\n", + "show_live_inference(\n", + " ie=ie,\n", + " image_paths=image_paths,\n", + " model=segmentation_model,\n", + " device=\"CPU\",\n", + " reader=lambda x: cv2.cvtColor(cv2.imread(x), cv2.COLOR_BGR2RGB),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c42b9127-74b5-4172-8104-5aacf6a22b9c", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "# Test multiclass segmentation with different input shape.\n", + "# This requires running the 102 notebook first, to generate the Fastseg model.\n", + "\n", + "fastseg_path = Path(\"../102-pytorch-onnx-to-openvino/model/fastseg1024.xml\")\n", + "image_path = \"../102-pytorch-onnx-to-openvino/data/street.jpg\"\n", + "\n", + "if fastseg_path.exists():\n", + " image_paths = [\n", + " image_path,\n", + " ] * 5\n", + "\n", + " ie = IECore()\n", + " CityScapesSegmentation = SegmentationMap(cityscape_labels)\n", + " segmentation_model = SegmentationModel(\n", + " ie,\n", + " fastseg_path,\n", + " sigmoid=False,\n", + " argmax=True,\n", + " colormap=CityScapesSegmentation.get_colormap(),\n", + " rgb=True,\n", + " )\n", + " show_live_inference(ie=ie, image_paths=image_paths, model=segmentation_model, device=\"CPU\")" + ] + }, + { + "cell_type": "markdown", + "id": "13eba0a6-1494-478c-ba01-e1ed6cdee608", + "metadata": { + "tags": [] + }, + "source": [ + "## OpenVINO Tools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0214f54b-0873-4200-8c3a-73760594cdf4", + "metadata": {}, + "outputs": [], + "source": [ + "def benchmark_model(\n", + " model_path: PathLike,\n", + " device: str = \"CPU\",\n", + " seconds: int = 60,\n", + " api: str = \"async\",\n", + " batch: int = 1,\n", + " cache_dir: PathLike = \"model_cache\",\n", + "):\n", + " \"\"\"\n", + " Benchmark model specified in `model_path` with `benchmark_app`. Returns the output of `benchmark_app`\n", + " without logging info, and information about the device.\n", + "\n", + " :param model_path: The path to an xml file of the OpenVINO IR model, or ONNX model.\n", + " :param device: A device to benchmark on. For example, \"CPU\" or \"MULTI:CPU,GPU\".\n", + " :param seconds: A number of seconds to run benchmark_app.\n", + " :param api: API. Possible options: sync or async.\n", + " :param batch: Batch size.\n", + " :param cache_dir: A directory that contains model/kernel cache files.\n", + " \"\"\"\n", + " ie = IECore()\n", + " model_path = Path(model_path)\n", + " if (\"GPU\" in device) and (\"GPU\" not in ie.available_devices):\n", + " raise ValueError(\n", + " f\"A GPU device is not available. Available devices are: {ie.available_devices}\"\n", + " )\n", + " else:\n", + " benchmark_command = f\"benchmark_app -m {model_path} -d {device} -t {seconds} -api {api} -b {batch} -cdir {cache_dir}\"\n", + " display(\n", + " Markdown(\n", + " f\"**Benchmark {model_path.name} with {device} for {seconds} seconds with {api} inference**\"\n", + " )\n", + " )\n", + " display(Markdown(f\"Benchmark command: `{benchmark_command}`\"))\n", + "\n", + " benchmark_output = get_ipython().run_line_magic(\"sx\", \"$benchmark_command\")\n", + " benchmark_result = [\n", + " line\n", + " for line in benchmark_output\n", + " if not (line.startswith(r\"[\") or line.startswith(\" \") or line == \"\")\n", + " ]\n", + " print(\"\\n\".join(benchmark_result))\n", + " print()\n", + " if \"MULTI\" in device:\n", + " devices = device.replace(\"MULTI:\", \"\").split(\",\")\n", + " for single_device in devices:\n", + " device_name = ie.get_metric(\n", + " device_name=single_device, metric_name=\"FULL_DEVICE_NAME\"\n", + " )\n", + " print(f\"{single_device} device: {device_name}\")\n", + " else:\n", + " print(f\"Device: {ie.get_metric(device_name=device, metric_name='FULL_DEVICE_NAME')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb29655c-d1d8-4f73-b56d-2389ef1cc237", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test OpenVINO Tools\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "093969fd-149d-4f6c-8e13-6ed6705170ed", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "ie = IECore()\n", + "model_url = \"https://github.com/openvinotoolkit/openvino_notebooks/raw/main/notebooks/002-openvino-api/model/segmentation.xml\"\n", + "model_path = download_ir_model(model_url, \"model\")\n", + "device = \"MULTI:CPU,GPU\" if \"GPU\" in ie.available_devices else \"CPU\"\n", + "display(Markdown(device))\n", + "benchmark_model(model_path=model_path, device=device, seconds=5)" + ] + }, + { + "cell_type": "markdown", + "id": "46431fa9", + "metadata": {}, + "source": [ + "## Checks and Alerts\n", + "\n", + "Create an alert class to show stylized info/error/warning messages and a `check_device` function that checks whether a given device is available." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f5ccdef", + "metadata": {}, + "outputs": [], + "source": [ + "class NotebookAlert(Exception):\n", + " def __init__(self, message: str, alert_class: str):\n", + " \"\"\"\n", + " Show an alert box with the given message.\n", + "\n", + " :param message: The message to display.\n", + " :param alert_class: The class for styling the message. Options: info, warning, success, danger.\n", + " \"\"\"\n", + " self.message = message\n", + " self.alert_class = alert_class\n", + " self.show_message()\n", + "\n", + " def show_message(self):\n", + " display(HTML(f\"\"\"
{self.message}\"\"\"))\n", + "\n", + "\n", + "class DeviceNotFoundAlert(NotebookAlert):\n", + " def __init__(self, device: str):\n", + " \"\"\"\n", + " Show a warning message about an unavailable device. This class does not check whether or\n", + " not the device is available, use `check_device` to check this. The `check_device` function\n", + " also shows the warning if the device is not found.\n", + "\n", + " :param device: The unavailable device.\n", + " :return: A formatted alert box with the message that `device` is not available, and a list\n", + " of devices that are available.\n", + " \"\"\"\n", + " ie = IECore()\n", + " supported_devices = ie.available_devices\n", + " self.message = (\n", + " f\"Running this cell requires a {device} device, \"\n", + " \"which is not available on this system. \"\n", + " )\n", + " self.alert_class = \"warning\"\n", + " if len(supported_devices) == 1:\n", + " self.message += f\"The following device is available: {ie.available_devices[0]}\"\n", + " else:\n", + " self.message += (\n", + " \"The following devices are available: \" f\"{', '.join(ie.available_devices)}\"\n", + " )\n", + " super().__init__(self.message, self.alert_class)\n", + "\n", + "\n", + "def check_device(device: str) -> bool:\n", + " \"\"\"\n", + " Check if the specified device is available on the system.\n", + "\n", + " :param device: Device to check. For example, CPU, GPU.\n", + " :return: True if the device is available, False if not. If the device is not available,\n", + " a `DeviceNotFoundAlert` message will be shown.\n", + " \"\"\"\n", + " ie = IECore()\n", + " if device not in ie.available_devices:\n", + " DeviceNotFoundAlert(device)\n", + " return False\n", + " else:\n", + " return True\n", + "\n", + "\n", + "def check_openvino_version(version: str) -> bool:\n", + " \"\"\"\n", + " Check if the specified OpenVINO version is installed.\n", + "\n", + " :param version: The OpenVINO version to check. Example: 2021.4.\n", + " :return: True if the version is installed, False if not. If the version is not installed,\n", + " an alert message will be shown.\n", + " \"\"\"\n", + " installed_version = openvino.inference_engine.get_version()\n", + " if version not in installed_version:\n", + " NotebookAlert(\n", + " f\"This notebook requires OpenVINO {version}. \"\n", + " f\"The version on your system is: {installed_version}.
\"\n", + " \"Run pip install --upgrade -r requirements.txt \"\n", + " \"in the 'openvino_env' environment to install this version. \"\n", + " \"See the \"\n", + " \"OpenVINO Notebooks README for detailed instructions\",\n", + " alert_class=\"danger\",\n", + " )\n", + " return False\n", + " else:\n", + " return True" + ] + }, + { + "cell_type": "markdown", + "id": "a19e1d08", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Alerts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7983c8f", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "NotebookAlert(message=\"Hello, world!\", alert_class=\"info\")\n", + "DeviceNotFoundAlert(\"GPU\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6bda8ef3", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "assert check_device(\"CPU\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "944820e1", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "if check_device(\"HELLOWORLD\"):\n", + " print(\"Hello World device found.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41c370ef", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "check_openvino_version(\"2022.1\");" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "interpreter": { + "hash": "ae617ccb002f72b3ab6d0069d721eac67ac2a969e83c083c4321cfcab0437cd1" + }, + "kernelspec": { + "display_name": "Python 3", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/session_3/openvino_notebooks/utils/notebook_utils.py b/session_3/openvino_notebooks/utils/notebook_utils.py new file mode 100644 index 0000000..0745459 --- /dev/null +++ b/session_3/openvino_notebooks/utils/notebook_utils.py @@ -0,0 +1,762 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[ ]: + + +import os +import shutil +import socket +import threading +import time +import urllib +import urllib.parse +import urllib.request +from os import PathLike +from pathlib import Path +from typing import Callable, List, NamedTuple, Optional, Tuple + +import cv2 +import matplotlib +import matplotlib.pyplot as plt +import numpy as np +import openvino.inference_engine +from async_pipeline import AsyncPipeline +from IPython.display import HTML, Image, Markdown, clear_output, display +from matplotlib.lines import Line2D +from models import model +from openvino.inference_engine import IECore +from tqdm.notebook import tqdm_notebook + + +# ## Files +# +# Load an image, download a file, download an IR model, and create a progress bar to show download progress. + +# In[ ]: + + +def load_image(path: str) -> np.ndarray: + """ + Loads an image from `path` and returns it as BGR numpy array. `path` + should point to an image file, either a local filename or a url. The image is + not stored to the filesystem. Use the `download_file` function to download and + store an image. + + :param path: Local path name or URL to image. + :return: image as BGR numpy array + """ + if path.startswith("http"): + # Set User-Agent to Mozilla because some websites block + # requests with User-Agent Python + request = urllib.request.Request(path, headers={"User-Agent": "Mozilla/5.0"}) + response = urllib.request.urlopen(request) + array = np.asarray(bytearray(response.read()), dtype="uint8") + image = cv2.imdecode(array, -1) # Loads the image as BGR + else: + image = cv2.imread(path) + return image + + +class DownloadProgressBar(tqdm_notebook): + """ + TQDM Progress bar for downloading files with urllib.request.urlretrieve + """ + + def update_to(self, block_num: int, block_size: int, total_size: int): + downloaded = block_num * block_size + if downloaded <= total_size: + self.update(downloaded - self.n) + + +def download_file( + url: PathLike, + filename: PathLike = None, + directory: PathLike = None, + show_progress: bool = True, + silent: bool = False, + timeout: int = 10, +) -> str: + """ + Download a file from a url and save it to the local filesystem. The file is saved to the + current directory by default, or to `directory` if specified. If a filename is not given, + the filename of the URL will be used. + + :param url: URL that points to the file to download + :param filename: Name of the local file to save. Should point to the name of the file only, + not the full path. If None the filename from the url will be used + :param directory: Directory to save the file to. Will be created if it doesn't exist + If None the file will be saved to the current working directory + :param show_progress: If True, show an TQDM ProgressBar + :param silent: If True, do not print a message if the file already exists + :param timeout: Number of seconds before cancelling the connection attempt + :return: path to downloaded file + """ + try: + opener = urllib.request.build_opener() + opener.addheaders = [("User-agent", "Mozilla/5.0")] + urllib.request.install_opener(opener) + urlobject = urllib.request.urlopen(url, timeout=timeout) + if filename is None: + filename = urlobject.info().get_filename() or Path(urllib.parse.urlparse(url).path).name + except urllib.error.HTTPError as e: + raise Exception(f"File downloading failed with error: {e.code} {e.msg}") from None + except urllib.error.URLError as error: + if isinstance(error.reason, socket.timeout): + raise Exception( + "Connection timed out. If you access the internet through a proxy server, please " + "make sure the proxy is set in the shell from where you launched Jupyter. If your " + "internet connection is slow, you can call `download_file(url, timeout=30)` to " + "wait for 30 seconds before raising this error." + ) from None + else: + raise + + filename = Path(filename) + if len(filename.parts) > 1: + raise ValueError( + "`filename` should refer to the name of the file, excluding the directory. " + "Use the `directory` parameter to specify a target directory for the downloaded file." + ) + + # create the directory if it does not exist, and add the directory to the filename + if directory is not None: + directory = Path(directory) + directory.mkdir(parents=True, exist_ok=True) + filename = directory / Path(filename) + + # download the file if it does not exist, or if it exists with an incorrect file size + urlobject_size = int(urlobject.info().get("Content-Length", 0)) + if not filename.exists() or (os.stat(filename).st_size != urlobject_size): + progress_callback = DownloadProgressBar( + total=urlobject_size, + unit="B", + unit_scale=True, + unit_divisor=1024, + desc=str(filename), + disable=not show_progress, + ) + urllib.request.urlretrieve(url, filename, reporthook=progress_callback.update_to) + if os.stat(filename).st_size >= urlobject_size: + progress_callback.update(urlobject_size - progress_callback.n) + progress_callback.refresh() + else: + if not silent: + print(f"'{filename}' already exists.") + return filename.resolve() + + +def download_ir_model(model_xml_url: str, destination_folder: PathLike = None) -> PathLike: + """ + Download IR model from `model_xml_url`. Downloads model xml and bin file; the weights file is + assumed to exist at the same location and name as model_xml_url with a ".bin" extension. + + :param model_xml_url: URL to model xml file to download + :param destination_folder: Directory where downloaded model xml and bin are saved. If None, model + files are saved to the current directory + :return: path to downloaded xml model file + """ + model_bin_url = model_xml_url[:-4] + ".bin" + model_xml_path = download_file(model_xml_url, directory=destination_folder, show_progress=False) + download_file(model_bin_url, directory=destination_folder) + return model_xml_path + + +# ## Images + +# ### Convert Pixel Data +# +# Normalize image pixel values between 0 and 1, and convert images to RGB and BGR. + +# In[ ]: + + +def normalize_minmax(data): + """ + Normalizes the values in `data` between 0 and 1 + """ + if data.max() == data.min(): + raise ValueError( + "Normalization is not possible because all elements of" + f"`data` have the same value: {data.max()}." + ) + return (data - data.min()) / (data.max() - data.min()) + + +def to_rgb(image_data: np.ndarray) -> np.ndarray: + """ + Convert image_data from BGR to RGB + """ + return cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB) + + +def to_bgr(image_data: np.ndarray) -> np.ndarray: + """ + Convert image_data from RGB to BGR + """ + return cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR) + + +# ## Videos + +# ### Video Player +# +# Custom video player to fulfill FPS requirements. You can set target FPS and output size, flip the video horizontally or skip first N frames. + +# In[ ]: + + +class VideoPlayer: + """ + Custom video player to fulfill FPS requirements. You can set target FPS and output size, + flip the video horizontally or skip first N frames. + + :param source: Video source. It could be either camera device or video file. + :param size: Output frame size. + :param flip: Flip source horizontally. + :param fps: Target FPS. + :param skip_first_frames: Skip first N frames. + """ + + def __init__(self, source, size=None, flip=False, fps=None, skip_first_frames=0): + self.__cap = cv2.VideoCapture(source) + if not self.__cap.isOpened(): + raise RuntimeError( + f"Cannot open {'camera' if isinstance(source, int) else ''} {source}" + ) + # skip first N frames + self.__cap.set(cv2.CAP_PROP_POS_FRAMES, skip_first_frames) + # fps of input file + self.__input_fps = self.__cap.get(cv2.CAP_PROP_FPS) + if self.__input_fps <= 0: + self.__input_fps = 60 + # target fps given by user + self.__output_fps = fps if fps is not None else self.__input_fps + self.__flip = flip + self.__size = None + self.__interpolation = None + if size is not None: + self.__size = size + # AREA better for shrinking, LINEAR better for enlarging + self.__interpolation = ( + cv2.INTER_AREA + if size[0] < self.__cap.get(cv2.CAP_PROP_FRAME_WIDTH) + else cv2.INTER_LINEAR + ) + # first frame + _, self.__frame = self.__cap.read() + self.__lock = threading.Lock() + self.__thread = None + self.__stop = False + + """ + Start playing. + """ + + def start(self): + self.__stop = False + self.__thread = threading.Thread(target=self.__run, daemon=True) + self.__thread.start() + + """ + Stop playing and release resources. + """ + + def stop(self): + self.__stop = True + if self.__thread is not None: + self.__thread.join() + self.__cap.release() + + def __run(self): + prev_time = 0 + while not self.__stop: + t1 = time.time() + ret, frame = self.__cap.read() + if not ret: + break + + # fulfill target fps + if 1 / self.__output_fps < time.time() - prev_time: + prev_time = time.time() + # replace by current frame + with self.__lock: + self.__frame = frame + + t2 = time.time() + # time to wait [s] to fulfill input fps + wait_time = 1 / self.__input_fps - (t2 - t1) + # wait until + time.sleep(max(0, wait_time)) + + self.__frame = None + + """ + Get current frame. + """ + + def next(self): + with self.__lock: + if self.__frame is None: + return None + # need to copy frame, because can be cached and reused if fps is low + frame = self.__frame.copy() + if self.__size is not None: + frame = cv2.resize(frame, self.__size, interpolation=self.__interpolation) + if self.__flip: + frame = cv2.flip(frame, 1) + return frame + + +# ## Visualization + +# ### Segmentation +# +# Define a SegmentationMap NamedTuple that keeps the labels and colormap for a segmentation project/dataset. Create CityScapesSegmentation and BinarySegmentation SegmentationMaps. Create a function to convert a segmentation map to an RGB image with a colormap, and to show the segmentation result as an overlay over the original image. + +# In[ ]: + + +class Label(NamedTuple): + index: int + color: Tuple + name: Optional[str] = None + + +# In[ ]: + + +class SegmentationMap(NamedTuple): + labels: List + + def get_colormap(self): + return np.array([label.color for label in self.labels]) + + def get_labels(self): + labelnames = [label.name for label in self.labels] + if any(labelnames): + return labelnames + else: + return None + + +# In[ ]: + + +cityscape_labels = [ + Label(index=0, color=(128, 64, 128), name="road"), + Label(index=1, color=(244, 35, 232), name="sidewalk"), + Label(index=2, color=(70, 70, 70), name="building"), + Label(index=3, color=(102, 102, 156), name="wall"), + Label(index=4, color=(190, 153, 153), name="fence"), + Label(index=5, color=(153, 153, 153), name="pole"), + Label(index=6, color=(250, 170, 30), name="traffic light"), + Label(index=7, color=(220, 220, 0), name="traffic sign"), + Label(index=8, color=(107, 142, 35), name="vegetation"), + Label(index=9, color=(152, 251, 152), name="terrain"), + Label(index=10, color=(70, 130, 180), name="sky"), + Label(index=11, color=(220, 20, 60), name="person"), + Label(index=12, color=(255, 0, 0), name="rider"), + Label(index=13, color=(0, 0, 142), name="car"), + Label(index=14, color=(0, 0, 70), name="truck"), + Label(index=15, color=(0, 60, 100), name="bus"), + Label(index=16, color=(0, 80, 100), name="train"), + Label(index=17, color=(0, 0, 230), name="motorcycle"), + Label(index=18, color=(119, 11, 32), name="bicycle"), + Label(index=19, color=(255, 255, 255), name="background"), +] + +CityScapesSegmentation = SegmentationMap(cityscape_labels) + +binary_labels = [ + Label(index=0, color=(255, 255, 255), name="background"), + Label(index=1, color=(0, 0, 0), name="foreground"), +] + +BinarySegmentation = SegmentationMap(binary_labels) + + +# In[ ]: + + +def segmentation_map_to_image( + result: np.ndarray, colormap: np.ndarray, remove_holes: bool = False +) -> np.ndarray: + """ + Convert network result of floating point numbers to an RGB image with + integer values from 0-255 by applying a colormap. + + :param result: A single network result after converting to pixel values in H,W or 1,H,W shape. + :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class. + :param remove_holes: If True, remove holes in the segmentation result. + :return: An RGB image where each pixel is an int8 value according to colormap. + """ + if len(result.shape) != 2 and result.shape[0] != 1: + raise ValueError( + f"Expected result with shape (H,W) or (1,H,W), got result with shape {result.shape}" + ) + + if len(np.unique(result)) > colormap.shape[0]: + raise ValueError( + f"Expected max {colormap[0]} classes in result, got {len(np.unique(result))} " + "different output values. Please make sure to convert the network output to " + "pixel values before calling this function." + ) + elif result.shape[0] == 1: + result = result.squeeze(0) + + result = result.astype(np.uint8) + + contour_mode = cv2.RETR_EXTERNAL if remove_holes else cv2.RETR_TREE + mask = np.zeros((result.shape[0], result.shape[1], 3), dtype=np.uint8) + for label_index, color in enumerate(colormap): + label_index_map = result == label_index + label_index_map = label_index_map.astype(np.uint8) * 255 + contours, hierarchies = cv2.findContours( + label_index_map, contour_mode, cv2.CHAIN_APPROX_SIMPLE + ) + cv2.drawContours( + mask, + contours, + contourIdx=-1, + color=color.tolist(), + thickness=cv2.FILLED, + ) + + return mask + + +def segmentation_map_to_overlay(image, result, alpha, colormap, remove_holes=False) -> np.ndarray: + """ + Returns a new image where a segmentation mask (created with colormap) is overlayed on + the source image. + + :param image: Source image. + :param result: A single network result after converting to pixel values in H,W or 1,H,W shape. + :param alpha: Alpha transparency value for the overlay image. + :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class. + :param remove_holes: If True, remove holes in the segmentation result. + :return: An RGP image with segmentation mask overlayed on the source image. + """ + if len(image.shape) == 2: + image = np.repeat(np.expand_dims(image, -1), 3, 2) + mask = segmentation_map_to_image(result, colormap, remove_holes) + image_height, image_width = image.shape[:2] + mask = cv2.resize(src=mask, dsize=(image_width, image_height)) + return cv2.addWeighted(mask, alpha, image, 1 - alpha, 0) + + +# ### Network Results +# +# Show network result image, optionally together with the source image and a legend with labels. + +# In[ ]: + + +def viz_result_image( + result_image: np.ndarray, + source_image: np.ndarray = None, + source_title: str = None, + result_title: str = None, + labels: List[Label] = None, + resize: bool = False, + bgr_to_rgb: bool = False, + hide_axes: bool = False, +) -> matplotlib.figure.Figure: + """ + Show result image, optionally together with source images, and a legend with labels. + + :param result_image: Numpy array of RGB result image. + :param source_image: Numpy array of source image. If provided this image will be shown + next to the result image. source_image is expected to be in RGB format. + Set bgr_to_rgb to True if source_image is in BGR format. + :param source_title: Title to display for the source image. + :param result_title: Title to display for the result image. + :param labels: List of labels. If provided, a legend will be shown with the given labels. + :param resize: If true, resize the result image to the same shape as the source image. + :param bgr_to_rgb: If true, convert the source image from BGR to RGB. Use this option if + source_image is a BGR image. + :param hide_axes: If true, do not show matplotlib axes. + :return: Matplotlib figure with result image + """ + if bgr_to_rgb: + source_image = to_rgb(source_image) + if resize: + result_image = cv2.resize(result_image, (source_image.shape[1], source_image.shape[0])) + + num_images = 1 if source_image is None else 2 + + fig, ax = plt.subplots(1, num_images, figsize=(16, 8), squeeze=False) + if source_image is not None: + ax[0, 0].imshow(source_image) + ax[0, 0].set_title(source_title) + + ax[0, num_images - 1].imshow(result_image) + ax[0, num_images - 1].set_title(result_title) + + if hide_axes: + for a in ax.ravel(): + a.axis("off") + if labels: + colors = labels.get_colormap() + lines = [ + Line2D( + [0], + [0], + color=[item / 255 for item in c.tolist()], + linewidth=3, + linestyle="-", + ) + for c in colors + ] + plt.legend( + lines, + labels.get_labels(), + bbox_to_anchor=(1, 1), + loc="upper left", + prop={"size": 12}, + ) + plt.close(fig) + return fig + + +# ### Live Inference + +# In[ ]: + + +def showarray(frame: np.ndarray, display_handle=None): + """ + Display array `frame`. Replace information at `display_handle` with `frame` + encoded as jpeg image. `frame` is expected to have data in BGR order. + + Create a display_handle with: `display_handle = display(display_id=True)` + """ + _, frame = cv2.imencode(ext=".jpeg", img=frame) + if display_handle is None: + display_handle = display(Image(data=frame.tobytes()), display_id=True) + else: + display_handle.update(Image(data=frame.tobytes())) + return display_handle + + +def show_live_inference( + ie, image_paths: List, model: model.Model, device: str, reader: Optional[Callable] = None +): + """ + Do inference of images listed in `image_paths` on `model` on the given `device` and show + the results in real time in a Jupyter Notebook + + :param image_paths: List of image filenames to load + :param model: Model instance for inference + :param device: Name of device to perform inference on. For example: "CPU" + :param reader: Image reader. Should return a numpy array with image data. + If None, cv2.imread will be used, with the cv2.IMREAD_UNCHANGED flag + """ + display_handle = None + next_frame_id = 0 + next_frame_id_to_show = 0 + + input_layer = next(iter(model.net.input_info)) + + # Create asynchronous pipeline and print time it takes to load the model + load_start_time = time.perf_counter() + pipeline = AsyncPipeline( + ie=ie, model=model, plugin_config={}, device=device, max_num_requests=0 + ) + load_end_time = time.perf_counter() + + # Perform asynchronous inference + start_time = time.perf_counter() + + while next_frame_id < len(image_paths) - 1: + results = pipeline.get_result(next_frame_id_to_show) + + if results: + # Show next result from async pipeline + result, meta = results + display_handle = showarray(result, display_handle) + next_frame_id_to_show += 1 + if pipeline.is_ready(): + # Submit new image to async pipeline + image_path = image_paths[next_frame_id] + if reader is None: + image = cv2.imread(filename=str(image_path), flags=cv2.IMREAD_UNCHANGED) + else: + image = reader(str(image_path)) + pipeline.submit_data( + inputs={input_layer: image}, id=next_frame_id, meta={"frame": image} + ) + del image + next_frame_id += 1 + else: + # If the pipeline is not ready yet and there are no results: wait + pipeline.await_any() + + pipeline.await_all() + + # Show all frames that are in the pipeline after all images have been submitted + while pipeline.has_completed_request(): + results = pipeline.get_result(next_frame_id_to_show) + if results: + result, meta = results + display_handle = showarray(result, display_handle) + next_frame_id_to_show += 1 + + end_time = time.perf_counter() + duration = end_time - start_time + fps = len(image_paths) / duration + print(f"Loaded model to {device} in {load_end_time-load_start_time:.2f} seconds.") + print(f"Total time for {next_frame_id} frames: {duration:.2f} seconds, fps:{fps:.2f}") + + del pipeline.exec_net + del pipeline + + +# ## OpenVINO Tools + +# In[ ]: + + +def benchmark_model( + model_path: PathLike, + device: str = "CPU", + seconds: int = 60, + api: str = "async", + batch: int = 1, + cache_dir: PathLike = "model_cache", +): + """ + Benchmark model `model_path` with `benchmark_app`. Returns the output of `benchmark_app` + without logging info, and information about the device + + :param model_path: path to IR model xml file, or ONNX model + :param device: device to benchmark on. For example, "CPU" or "MULTI:CPU,GPU" + :param seconds: number of seconds to run benchmark_app + :param api: API. Possible options: sync or async + :param batch: Batch size + :param cache_dir: Directory that contains model/kernel cache files + """ + ie = IECore() + model_path = Path(model_path) + if ("GPU" in device) and ("GPU" not in ie.available_devices): + raise ValueError( + f"A GPU device is not available. Available devices are: {ie.available_devices}" + ) + else: + benchmark_command = f"benchmark_app -m {model_path} -d {device} -t {seconds} -api {api} -b {batch} -cdir {cache_dir}" + display( + Markdown( + f"**Benchmark {model_path.name} with {device} for {seconds} seconds with {api} inference**" + ) + ) + display(Markdown(f"Benchmark command: `{benchmark_command}`")) + + benchmark_output = get_ipython().run_line_magic("sx", "$benchmark_command") + benchmark_result = [ + line + for line in benchmark_output + if not (line.startswith(r"[") or line.startswith(" ") or line == "") + ] + print("\n".join(benchmark_result)) + print() + if "MULTI" in device: + devices = device.replace("MULTI:", "").split(",") + for single_device in devices: + device_name = ie.get_metric( + device_name=single_device, metric_name="FULL_DEVICE_NAME" + ) + print(f"{single_device} device: {device_name}") + else: + print(f"Device: {ie.get_metric(device_name=device, metric_name='FULL_DEVICE_NAME')}") + + +# ## Checks and Alerts +# +# Create an alert class to show stylized info/error/warning messages and a `check_device` function that checks whether a given device is available. + +# In[ ]: + + +class NotebookAlert(Exception): + def __init__(self, message: str, alert_class: str): + """ + Show an alert box with the given message. + + :param message: The message to display. + :param alert_class: The class for styling the message. Options: info, warning, success, danger. + """ + self.message = message + self.alert_class = alert_class + self.show_message() + + def show_message(self): + display(HTML(f"""
{self.message}""")) + + +class DeviceNotFoundAlert(NotebookAlert): + def __init__(self, device: str): + """ + Show a warning message about an unavailable device. This class does not check whether or + not the device is available, use the `check_device` function to check this. `check_device` + also shows the warning if the device is not found. + + :param device: The unavailable device. + :return: A formatted alert box with the message that `device` is not available, and a list + of devices that are available. + """ + ie = IECore() + supported_devices = ie.available_devices + self.message = ( + f"Running this cell requires a {device} device, " + "which is not available on this system. " + ) + self.alert_class = "warning" + if len(supported_devices) == 1: + self.message += f"The following device is available: {ie.available_devices[0]}" + else: + self.message += ( + "The following devices are available: " f"{', '.join(ie.available_devices)}" + ) + super().__init__(self.message, self.alert_class) + + +def check_device(device: str) -> bool: + """ + Check if the specified device is available on the system. + + :param device: Device to check. e.g. CPU, GPU + :return: True if the device is available, False if not. If the device is not available, + a DeviceNotFoundAlert will be shown. + """ + ie = IECore() + if device not in ie.available_devices: + DeviceNotFoundAlert(device) + return False + else: + return True + + +def check_openvino_version(version: str) -> bool: + """ + Check if the specified OpenVINO version is installed. + + :param version: the OpenVINO version to check. Example: 2021.4 + :return: True if the version is installed, False if not. If the version is not installed, + an alert message will be shown. + """ + installed_version = openvino.inference_engine.get_version() + if version not in installed_version: + NotebookAlert( + f"This notebook requires OpenVINO {version}. " + f"The version on your system is: {installed_version}.
" + "Please run pip install --upgrade -r requirements.txt " + "in the openvino_env environment to install this version. " + "See the " + "OpenVINO Notebooks README for detailed instructions", + alert_class="danger", + ) + return False + else: + return True + diff --git a/session_4/notebooks/301-tensorflow-training-openvino-pot.ipynb b/session_4/notebooks/301-tensorflow-training-openvino-pot.ipynb new file mode 100644 index 0000000..b097f3f --- /dev/null +++ b/session_4/notebooks/301-tensorflow-training-openvino-pot.ipynb @@ -0,0 +1,704 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "KwQtSOz0VrVX", + "tags": [] + }, + "source": [ + "# Post-Training Quantization with TensorFlow Classification Model\n", + "\n", + "This example demonstrates how to quantize the OpenVINO model that was created in [301-tensorflow-training-openvino.ipynb](301-tensorflow-training-openvino.ipynb), to improve inference speed. Quantization is performed with [Post-Training Optimization Tool (POT)](https://docs.openvino.ai/nightly/pot_README.html). A custom dataloader and metric will be defined, and accuracy and performance will be computed for the original IR model and the quantized model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KwQtSOz0VrVX" + }, + "source": [ + "## Preparation\n", + "\n", + "The notebook requires that the training notebook has been run and that the Intermediate Representation (IR) models are created. If the IR models do not exist, running the next cell will run the training notebook. This will take a while." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide_output" + ], + "test_replace": { + "301-tensorflow-training-openvino.ipynb": "test_301-tensorflow-training-openvino.ipynb" + } + }, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import tensorflow as tf\n", + "\n", + "model_xml = Path(\"model/flower/flower_ir.xml\")\n", + "dataset_url = (\n", + " \"https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\"\n", + ")\n", + "data_dir = Path(tf.keras.utils.get_file(\"flower_photos\", origin=dataset_url, untar=True))\n", + "\n", + "if not model_xml.exists():\n", + " print(\"Executing training notebook. This will take a while...\")\n", + " %run 301-tensorflow-training-openvino.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xG4gTnxHXn3z" + }, + "source": [ + "### Imports\n", + "\n", + "The Post Training Optimization API is implemented in the `compression` library." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Wi2JvOs1Xn3z", + "tags": [] + }, + "outputs": [], + "source": [ + "import copy\n", + "import os\n", + "import sys\n", + "\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from addict import Dict\n", + "from openvino.tools.pot.api import Metric, DataLoader\n", + "from openvino.tools.pot.graph import load_model, save_model\n", + "from openvino.tools.pot.graph.model_utils import compress_model_weights\n", + "from openvino.tools.pot.engines.ie_engine import IEEngine\n", + "from openvino.tools.pot.pipeline.initializer import create_pipeline\n", + "from openvino.runtime import Core\n", + "from PIL import Image\n", + "\n", + "sys.path.append(\"../utils\")\n", + "from notebook_utils import benchmark_model, download_file" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7M6TsJjlXn30" + }, + "source": [ + "### Settings\n", + "\n", + "In the next cell, the settings for running quantization are defined. The default settings use the _mixed_ preset and the _DefaultQuantization_ algorithm. This enables reasonably fast quantization, with possible drop in accuracy. The _performance_ preset can result in faster inference on the quantized model, the _AccuracyAwareQuantization_ algorithm quantizes the model to a defined maximal accuracy drop, which may not achieve the greatest performance boost but avoids further drop in accuracy. \n", + "\n", + "See the [Post-Training Optimization Best Practices](https://docs.openvino.ai/latest/pot_docs_BestPractices.html) page for more information about the configurable parameters and best practices for post-training quantization.\n", + "\n", + "The POT methods expect configuration dictionaries as arguments. They are defined in the cell below. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Lb_BnWSpXn30", + "tags": [], + "test_replace": { + "\"stat_subset_size\": 1000,": "\"stat_subset_size\": 25," + } + }, + "outputs": [], + "source": [ + "model_config = Dict(\n", + " {\n", + " \"model_name\": \"flower\",\n", + " \"model\": \"model/flower/flower_ir.xml\",\n", + " \"weights\": \"model/flower/flower_ir.bin\",\n", + " }\n", + ")\n", + "\n", + "engine_config = Dict({\"device\": \"CPU\", \"stat_requests_number\": 2, \"eval_requests_number\": 2})\n", + "\n", + "algorithms = [\n", + " {\n", + " \"name\": \"DefaultQuantization\",\n", + " \"params\": {\n", + " \"target_device\": \"CPU\",\n", + " \"preset\": \"performance\",\n", + " \"stat_subset_size\": 1000,\n", + " },\n", + " }\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IVZ7GGu2Xn3z" + }, + "source": [ + "### Create DataLoader Class\n", + "\n", + "OpenVINO's compression library contains a DataLoader class. The DataLoader defines how to load data and annotations. For the TensorFlow flowers dataset, images are stored in a directory per category. The DataLoader loads images from a given _data_source_ directory and assigns a label based on the position of the directory in _class_names_ (where class_names is a list of directory names in alphabetical order)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "122wcKhzXn3z", + "tags": [], + "test_replace": { + "return len(self.dataset)": "return 30" + } + }, + "outputs": [], + "source": [ + "class ClassificationDataLoader(DataLoader):\n", + " \"\"\"\n", + " DataLoader for image data that is stored in a directory per category. For example, for\n", + " categories _rose_ and _daisy_, rose images are expected in data_source/rose, daisy images\n", + " in data_source/daisy.\n", + " \"\"\"\n", + "\n", + " def __init__(self, data_source):\n", + " \"\"\"\n", + " :param data_source: path to data directory\n", + " \"\"\"\n", + " self.data_source = Path(data_source)\n", + " self.dataset = [p for p in data_dir.glob(\"**/*\") if p.suffix in (\".png\", \".jpg\")]\n", + " self.class_names = sorted([item.name for item in Path(data_dir).iterdir() if item.is_dir()])\n", + "\n", + " def __len__(self):\n", + " \"\"\"\n", + " Returns the number of elements in the dataset\n", + " \"\"\"\n", + " return len(self.dataset)\n", + "\n", + " def __getitem__(self, index):\n", + " \"\"\"\n", + " Get item from self.dataset at the specified index.\n", + " Returns (annotation, image), where annotation is a tuple (index, class_index)\n", + " and image a preprocessed image in network shape\n", + " \"\"\"\n", + " if index >= len(self):\n", + " raise IndexError\n", + " filepath = self.dataset[index]\n", + " annotation = (index, self.class_names.index(filepath.parent.name))\n", + " image = self._read_image(filepath)\n", + " return annotation, image\n", + "\n", + " def _read_image(self, index):\n", + " \"\"\"\n", + " Read image at dataset[index] to memory, resize, convert to BGR and to network shape\n", + "\n", + " :param index: dataset index to read\n", + " :return ndarray representation of image batch\n", + " \"\"\"\n", + " image = cv2.imread(os.path.join(self.data_source, index))[:, :, (2, 1, 0)]\n", + " image = cv2.resize(image, (180, 180)).astype(np.float32)\n", + " return image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_eREaJb5Xn3z" + }, + "source": [ + "### Create Accuracy Metric Class\n", + "\n", + "The accuracy metric is defined as the number of correct predictions divided by the total number of predictions. It is used to validate the accuracy of the quantized model.\n", + "\n", + "The Accuracy class in this tutorial implements the `Metric` interface of the compression library." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4fBKPFMzXn30" + }, + "outputs": [], + "source": [ + "class Accuracy(Metric):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self._name = \"accuracy\"\n", + " self._matches = []\n", + "\n", + " @property\n", + " def value(self):\n", + " \"\"\"Returns accuracy metric value for the last model output.\"\"\"\n", + " return {self._name: self._matches[-1]}\n", + "\n", + " @property\n", + " def avg_value(self):\n", + " \"\"\"\n", + " Returns accuracy metric value for all model outputs. Results per image are stored in\n", + " self._matches, where True means a correct prediction and False a wrong prediction.\n", + " Accuracy is computed as the number of correct predictions divided by the total\n", + " number of predictions.\n", + " \"\"\"\n", + " num_correct = np.count_nonzero(self._matches)\n", + " return {self._name: num_correct / len(self._matches)}\n", + "\n", + " def update(self, output, target):\n", + " \"\"\"Updates prediction matches.\n", + "\n", + " :param output: model output\n", + " :param target: annotations\n", + " \"\"\"\n", + " predict = np.argmax(output[0], axis=1)\n", + " match = predict == target\n", + " self._matches.append(match)\n", + "\n", + " def reset(self):\n", + " \"\"\"\n", + " Resets the Accuracy metric. This is a required method that should initialize all\n", + " attributes to their initial value.\n", + " \"\"\"\n", + " self._matches = []\n", + "\n", + " def get_attributes(self):\n", + " \"\"\"\n", + " Returns a dictionary of metric attributes {metric_name: {attribute_name: value}}.\n", + " Required attributes: 'direction': 'higher-better' or 'higher-worse'\n", + " 'type': metric type\n", + " \"\"\"\n", + " return {self._name: {\"direction\": \"higher-better\", \"type\": \"accuracy\"}}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mgaRN7mTXn30" + }, + "source": [ + "## POT Optimization\n", + "\n", + "After creating the DataLoader and Metric classes, and defining the configuration settings for POT, we can start the quantization process." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RjywhxvqXn30" + }, + "outputs": [], + "source": [ + "# Step 1: Load the model\n", + "model = load_model(model_config=model_config)\n", + "original_model = copy.deepcopy(model)\n", + "\n", + "# Step 2: Initialize the data loader\n", + "data_loader = ClassificationDataLoader(data_source=data_dir)\n", + "\n", + "# Step 3 (Optional. Required for AccuracyAwareQuantization): Initialize the metric\n", + "# Compute metric results on original model\n", + "metric = Accuracy()\n", + "\n", + "# Step 4: Initialize the engine for metric calculation and statistics collection\n", + "engine = IEEngine(config=engine_config, data_loader=data_loader, metric=metric)\n", + "\n", + "# Step 5: Create a pipeline of compression algorithms\n", + "pipeline = create_pipeline(algo_config=algorithms, engine=engine)\n", + "\n", + "# Step 6: Execute the pipeline\n", + "compressed_model = pipeline.run(model=model)\n", + "\n", + "# Step 7 (Optional): Compress model weights quantized precision\n", + "# in order to reduce the size of final .bin file\n", + "compress_model_weights(model=compressed_model)\n", + "\n", + "# Step 8: Save the compressed model and get the path to the model\n", + "compressed_model_paths = save_model(\n", + " model=compressed_model, save_path=os.path.join(os.path.curdir, \"model/optimized\")\n", + ")\n", + "compressed_model_xml = Path(compressed_model_paths[0][\"model\"])\n", + "print(f\"The quantized model is stored in {compressed_model_xml}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RjywhxvqXn30" + }, + "outputs": [], + "source": [ + "# Step 9 (Optional): Evaluate the original and compressed model. Print the results\n", + "original_metric_results = pipeline.evaluate(original_model)\n", + "if original_metric_results:\n", + " print(f\"Accuracy of the original model: {next(iter(original_metric_results.values())):.5f}\")\n", + "\n", + "quantized_metric_results = pipeline.evaluate(compressed_model)\n", + "if quantized_metric_results:\n", + " print(f\"Accuracy of the quantized model: {next(iter(quantized_metric_results.values())):.5f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DJbP4pdEXn30" + }, + "source": [ + "## Run Inference on Quantized Model\n", + "\n", + "Copy the preprocess function from the training notebook and run inference on the quantized model with Inference Engine. See the [OpenVINO API tutorial](../002-openvino-api/002-openvino-api.ipynb) for more information about running inference with Inference Engine Python API." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def pre_process_image(imagePath, img_height=180):\n", + " # Model input format\n", + " n, c, h, w = [1, 3, img_height, img_height]\n", + " image = Image.open(imagePath)\n", + " image = image.resize((h, w), resample=Image.BILINEAR)\n", + "\n", + " # Convert to array and change data layout from HWC to CHW\n", + " image = np.array(image)\n", + "\n", + " input_image = image.reshape((n, h, w, c))\n", + "\n", + " return input_image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "q8lGxI-1Xn31" + }, + "outputs": [], + "source": [ + "# Load the optimized model and get the names of the input and output layer\n", + "ie = Core()\n", + "model_pot = ie.read_model(model=\"model/optimized/flower_ir.xml\")\n", + "compiled_model_pot = ie.compile_model(model=model_pot, device_name=\"CPU\")\n", + "input_layer = compiled_model_pot.input(0)\n", + "output_layer = compiled_model_pot.output(0)\n", + "\n", + "# Get the class names: a list of directory names in alphabetical order\n", + "class_names = sorted([item.name for item in Path(data_dir).iterdir() if item.is_dir()])\n", + "\n", + "# Run inference on an input image...\n", + "inp_img_url = (\n", + " \"https://upload.wikimedia.org/wikipedia/commons/4/48/A_Close_Up_Photo_of_a_Dandelion.jpg\"\n", + ")\n", + "directory = \"output\"\n", + "inp_file_name = \"A_Close_Up_Photo_of_a_Dandelion.jpg\"\n", + "file_path = Path(directory)/Path(inp_file_name)\n", + "# Download the image if it does not exist yet\n", + "if not Path(inp_file_name).exists():\n", + " download_file(inp_img_url, inp_file_name, directory=directory)\n", + "\n", + "# Pre-process the image and get it ready for inference.\n", + "input_image = pre_process_image(imagePath=file_path)\n", + "print(f'input image shape: {input_image.shape}')\n", + "print(f'input layer shape: {input_layer.shape}')\n", + "\n", + "res = compiled_model_pot([input_image])[output_layer]\n", + "\n", + "score = tf.nn.softmax(res[0])\n", + "\n", + "# Show the results\n", + "image = Image.open(file_path)\n", + "plt.imshow(image)\n", + "print(\n", + " \"This image most likely belongs to {} with a {:.2f} percent confidence.\".format(\n", + " class_names[np.argmax(score)], 100 * np.max(score)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compare Inference Speed\n", + "\n", + "Measure inference speed with the [OpenVINO Benchmark App](https://docs.openvino.ai/latest/openvino_inference_engine_tools_benchmark_tool_README.html). \n", + "\n", + "Benchmark App is a command line tool that measures raw inference performance for a specified OpenVINO IR model. Run `benchmark_app --help` to see a list of available parameters. By default, Benchmark App tests the performance of the model specified with the `-m` parameter with asynchronous inference on CPU, for one minute. Use the `-d` parameter to test performance on a different device, for example an Intel integrated Graphics (iGPU), and `-t` to set the number of seconds to run inference. See the [documentation](https://docs.openvino.ai/latest/openvino_inference_engine_tools_benchmark_tool_README.html) for more information. \n", + "\n", + "In this tutorial, we use a wrapper function from [Notebook Utils](https://github.com/openvinotoolkit/openvino_notebooks/blob/main/notebooks/utils/notebook_utils.ipynb). It prints the `benchmark_app` command with the chosen parameters.\n", + "\n", + "In the next cells, inference speed will be measured for the original and quantized model on CPU. If an iGPU is available, inference speed will be measured for CPU+GPU as well. The number of seconds is set to 15.\n", + "\n", + "> NOTE: For the most accurate performance estimation, we recommended running `benchmark_app` in a terminal/command prompt after closing other applications." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print the available devices on this system\n", + "ie = Core()\n", + "print(\"Device information:\")\n", + "print(ie.get_property(\"CPU\", \"FULL_DEVICE_NAME\"))\n", + "if \"GPU\" in ie.available_devices:\n", + " print(ie.get_property(\"GPU\", \"FULL_DEVICE_NAME\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "seconds=15": "seconds=3" + } + }, + "outputs": [], + "source": [ + "# Original model - CPU\n", + "benchmark_model(model_path=model_xml, device=\"CPU\", seconds=15, api='async')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "seconds=15": "seconds=3" + } + }, + "outputs": [], + "source": [ + "# Quantized model - CPU\n", + "benchmark_model(model_path=compressed_model_xml, device=\"CPU\", seconds=15, api='async')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-0eZaw1W5-wt" + }, + "source": [ + "**Benchmark on MULTI:CPU,GPU**\n", + "\n", + "With a recent Intel CPU, the best performance can often be achieved by doing inference on both the CPU and the iGPU, with OpenVINO's [Multi Device Plugin](https://docs.openvino.ai/2021.4/openvino_docs_IE_DG_supported_plugins_MULTI.html). It takes a bit longer to load a model on GPU than on CPU, so this benchmark will take a bit longer to complete than the CPU benchmark, when run for the first time. Benchmark App supports caching, by specifying the `--cdir` parameter. In the cells below, the model will cached to the `model_cache` directory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "seconds=15": "seconds=3" + } + }, + "outputs": [], + "source": [ + "# Original model - MULTI:CPU,GPU\n", + "if \"GPU\" in ie.available_devices:\n", + " benchmark_model(model_path=model_xml, device=\"MULTI:CPU,GPU\", seconds=15, api='async')\n", + "else:\n", + " print(\"A supported integrated GPU is not available on this system.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "seconds=15": "seconds=3" + } + }, + "outputs": [], + "source": [ + "# Quantized model - MULTI:CPU,GPU\n", + "if \"GPU\" in ie.available_devices:\n", + " benchmark_model(model_path=compressed_model_xml, device=\"MULTI:CPU,GPU\", seconds=15, api='async')\n", + "else:\n", + " print(\"A supported integrated GPU is not available on this system.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print the available devices on this system\n", + "print(\"Device information:\")\n", + "print(ie.get_property(\"CPU\", \"FULL_DEVICE_NAME\"))\n", + "if \"GPU\" in ie.available_devices:\n", + " print(ie.get_property(\"GPU\", \"FULL_DEVICE_NAME\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-0eZaw1W5-wt" + }, + "source": [ + "**Original IR model - CPU**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "-t 15": "-t 3" + } + }, + "outputs": [], + "source": [ + "benchmark_output = %sx benchmark_app -m $model_xml -t 15 -api async\n", + "# Remove logging info from benchmark_app output and show only the results\n", + "benchmark_result = [line for line in benchmark_output if not (line.startswith(r\"[\") or line.startswith(\" \") or line==\"\")]\n", + "print(\"\\n\".join(benchmark_result))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-0eZaw1W5-wt" + }, + "source": [ + "**Quantized IR model - CPU**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "-t 15": "-t 3" + } + }, + "outputs": [], + "source": [ + "benchmark_output = %sx benchmark_app -m $compressed_model_xml -t 15 -api async\n", + "# Remove logging info from benchmark_app output and show only the results\n", + "benchmark_result = [line for line in benchmark_output if not (line.startswith(r\"[\") or line.startswith(\" \") or line==\"\")]\n", + "print(\"\\n\".join(benchmark_result))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-0eZaw1W5-wt" + }, + "source": [ + "**Original IR model - MULTI:CPU,GPU**\n", + "\n", + "With a recent Intel CPU, the best performance can often be achieved by doing inference on both the CPU and the iGPU, with OpenVINO's [Multi Device Plugin](https://docs.openvino.ai/latest/openvino_docs_OV_UG_Running_on_multiple_devices.html). It takes a bit longer to load a model on GPU than on CPU, so this benchmark will take a bit longer to complete than the CPU benchmark." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "-t 15": "-t 3" + } + }, + "outputs": [], + "source": [ + "ie = Core()\n", + "if \"GPU\" in ie.available_devices:\n", + " benchmark_output = %sx benchmark_app -m $model_xml -d MULTI:CPU,GPU -t 15 -api async\n", + " # Remove logging info from benchmark_app output and show only the results\n", + " benchmark_result = [line for line in benchmark_output if not (line.startswith(r\"[\") or line.startswith(\" \") or line==\"\")]\n", + " print(\"\\n\".join(benchmark_result))\n", + "else:\n", + " print(\"An integrated GPU is not available on this system.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-0eZaw1W5-wt" + }, + "source": [ + "**Quantized IR model - MULTI:CPU,GPU**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-0eZaw1W5-wt", + "tags": [], + "test_replace": { + "-t 15": "-t 3" + } + }, + "outputs": [], + "source": [ + "ie = Core()\n", + "if \"GPU\" in ie.available_devices:\n", + " benchmark_output = %sx benchmark_app -m $compressed_model_xml -d MULTI:CPU,GPU -t 15 -api async\n", + " # Remove logging info from benchmark_app output and show only the results\n", + " benchmark_result = [line for line in benchmark_output if not (line.startswith(r\"[\") or line.startswith(\" \") or line==\"\")]\n", + " print(\"\\n\".join(benchmark_result))\n", + "else:\n", + " print(\"An integrated GPU is not available on this system.\")" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "301-tensorflow-training-openvino-pot.ipynb", + "provenance": [], + "toc_visible": true + }, + "interpreter": { + "hash": "8e25c8ed6cc2cfe6c8620be5042bb64fac4c236f57496fb5eb68e9ea1795f1fe" + }, + "kernelspec": { + "display_name": "openvino_env", + "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.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/session_4/notebooks/301-tensorflow-training-openvino.ipynb b/session_4/notebooks/301-tensorflow-training-openvino.ipynb new file mode 100644 index 0000000..bc72660 --- /dev/null +++ b/session_4/notebooks/301-tensorflow-training-openvino.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# From Training to Deployment with TensorFlow and OpenVINO™ " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "\n", + "# Copyright 2018 The TensorFlow Authors\n", + "#\n", + "# Modified for OpenVINO Notebooks" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KwQtSOz0VrVX" + }, + "source": [ + "This tutorial demonstrates how to train, convert, and deploy an image classification model with TensorFlow and OpenVINO. This particular notebook shows the process where we perform the inference step on the freshly trained model that is converted to OpenVINO IR with Model Optimizer. For faster inference speed on the model created in this notebook, check out the [Post-Training Quantization with TensorFlow Classification Model](./301-tensorflow-training-openvino-pot.ipynb) notebook.\n", + "\n", + "\n", + "This training code comprises the official [TensorFlow Image Classification Tutorial](https://www.tensorflow.org/tutorials/images/classification) in its entirety.\n", + "\n", + "The **flower_ir.bin** and **flower_ir.xml** (pre-trained models) can be obtained by executing the code with 'Runtime->Run All' or the Ctrl+F9 command." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TensorFlow Image Classification Training" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gN7G9GFmVrVY" + }, + "source": [ + "The first part of the tutorial shows how to classify images of flowers (based on the TensorFlow's official tutorial). It creates an image classifier using a `keras.Sequential` model, and loads data using `preprocessing.image_dataset_from_directory`. You will gain practical experience with the following concepts:\n", + "\n", + "* Efficiently loading a dataset off disk.\n", + "* Identifying overfitting and applying techniques to mitigate it, including data augmentation and Dropout.\n", + "\n", + "This tutorial follows a basic machine learning workflow:\n", + "\n", + "1. Examine and understand data\n", + "2. Build an input pipeline\n", + "3. Build the model\n", + "4. Train the model\n", + "5. Test the model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zF9uvbXNVrVY" + }, + "source": [ + "## Import TensorFlow and Other Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "L1WtoaOHVrVh" + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "import PIL\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from PIL import Image\n", + "from openvino.runtime import Core\n", + "from openvino.tools.mo import mo_tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "from tensorflow.keras.models import Sequential\n", + "\n", + "sys.path.append(\"../utils\")\n", + "from notebook_utils import download_file" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UZZI6lNkVrVm" + }, + "source": [ + "## Download and Explore the Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DPHx8-t-VrVo" + }, + "source": [ + "This tutorial uses a dataset of about 3,700 photos of flowers. The dataset contains 5 sub-directories, one per class:\n", + "\n", + "```\n", + "flower_photo/\n", + " daisy/\n", + " dandelion/\n", + " roses/\n", + " sunflowers/\n", + " tulips/\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "57CcilYSG0zv" + }, + "outputs": [], + "source": [ + "import pathlib\n", + "dataset_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\"\n", + "data_dir = tf.keras.utils.get_file('flower_photos', origin=dataset_url, untar=True)\n", + "data_dir = pathlib.Path(data_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VpmywIlsVrVx" + }, + "source": [ + "After downloading, you should now have a copy of the dataset available. There are 3,670 total images:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SbtTDYhOHZb6" + }, + "outputs": [], + "source": [ + "image_count = len(list(data_dir.glob('*/*.jpg')))\n", + "print(image_count)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PVmwkOSdHZ5A" + }, + "source": [ + "Here are some roses:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "N1loMlbYHeiJ" + }, + "outputs": [], + "source": [ + "roses = list(data_dir.glob('roses/*'))\n", + "PIL.Image.open(str(roses[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RQbZBOTLHiUP" + }, + "outputs": [], + "source": [ + "PIL.Image.open(str(roses[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DGEqiBbRHnyI" + }, + "source": [ + "And some tulips:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HyQkfPGdHilw" + }, + "outputs": [], + "source": [ + "tulips = list(data_dir.glob('tulips/*'))\n", + "PIL.Image.open(str(tulips[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wtlhWJPAHivf" + }, + "outputs": [], + "source": [ + "PIL.Image.open(str(tulips[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gIjgz7_JIo_m" + }, + "source": [ + "## Load Using keras.preprocessing\n", + "\n", + "Let's load these images off disk using the helpful [image_dataset_from_directory](https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image_dataset_from_directory) utility. This will take you from a directory of images on disk to a `tf.data.Dataset` in just a couple lines of code. If you like, you can also write your own data loading code from scratch by visiting the [load images](https://www.tensorflow.org/tutorials/load_data/images) tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xyDNn9MbIzfT" + }, + "source": [ + "## Create a Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "anqiK_AGI086" + }, + "source": [ + "Define some parameters for the loader:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "H74l2DoDI2XD" + }, + "outputs": [], + "source": [ + "batch_size = 32\n", + "img_height = 180\n", + "img_width = 180" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pFBhRrrEI49z" + }, + "source": [ + "It's good practice to use a validation split when developing your model. Let's use 80% of the images for training, and 20% for validation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "fIR0kRZiI_AT" + }, + "outputs": [], + "source": [ + "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " data_dir,\n", + " validation_split=0.2,\n", + " subset=\"training\",\n", + " seed=123,\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iscU3UoVJBXj" + }, + "outputs": [], + "source": [ + "val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " data_dir,\n", + " validation_split=0.2,\n", + " subset=\"validation\",\n", + " seed=123,\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WLQULyAvJC3X" + }, + "source": [ + "You can find the class names in the `class_names` attribute on these datasets. These correspond to the directory names in alphabetical order." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ZHAxkHX5JD3k" + }, + "outputs": [], + "source": [ + "class_names = train_ds.class_names\n", + "print(class_names)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_uoVvxSLJW9m" + }, + "source": [ + "## Visualize the Data\n", + "\n", + "Here are the first 9 images from the training dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wBmEA9c0JYes" + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images, labels in train_ds.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i].numpy().astype(\"uint8\"))\n", + " plt.title(class_names[labels[i]])\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5M6BXtXFJdW0" + }, + "source": [ + "You will train a model using these datasets by passing them to `model.fit` in a moment. If you like, you can also manually iterate over the dataset and retrieve batches of images:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2-MfMoenJi8s" + }, + "outputs": [], + "source": [ + "for image_batch, labels_batch in train_ds:\n", + " print(image_batch.shape)\n", + " print(labels_batch.shape)\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Wj4FrKxxJkoW" + }, + "source": [ + "The `image_batch` is a tensor of the shape `(32, 180, 180, 3)`. This is a batch of 32 images of shape `180x180x3` (the last dimension refers to color channels RGB). The `label_batch` is a tensor of the shape `(32,)`, these are corresponding labels to the 32 images. \n", + "\n", + "You can call `.numpy()` on the `image_batch` and `labels_batch` tensors to convert them to a `numpy.ndarray`.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4Dr0at41KcAU" + }, + "source": [ + "## Configure the Dataset for Performance\n", + "\n", + "Let's make sure to use buffered prefetching so you can yield data from disk without having I/O become blocking. These are two important methods you should use when loading data.\n", + "\n", + "`Dataset.cache()` keeps the images in memory after they're loaded off disk during the first epoch. This will ensure the dataset does not become a bottleneck while training your model. If your dataset is too large to fit into memory, you can also use this method to create a performant on-disk cache.\n", + "\n", + "`Dataset.prefetch()` overlaps data preprocessing and model execution while training. \n", + "\n", + "Interested readers can learn more about both methods, as well as how to cache data to disk in the [data performance guide](https://www.tensorflow.org/guide/data_performance#prefetching)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "nOjJSm7DKoZA" + }, + "outputs": [], + "source": [ + "# AUTOTUNE = tf.data.AUTOTUNE\n", + "AUTOTUNE = tf.data.experimental.AUTOTUNE\n", + "train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)\n", + "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8GUnmPF4JvEf" + }, + "source": [ + "## Standardize the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e56VXHMWJxYT" + }, + "source": [ + "The RGB channel values are in the `[0, 255]` range. This is not ideal for a neural network; in general you should seek to make your input values small. Here, you will standardize values to be in the `[0, 1]` range by using a Rescaling layer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PEYxo2CTJvY9" + }, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(1./255)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8aGpkwFaIw4i" + }, + "source": [ + "Note: The Keras Preprocessing utilities and layers introduced in this section are currently experimental and may change." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Bl4RmanbJ4g0" + }, + "source": [ + "There are two ways to use this layer. You can apply it to the dataset by calling map:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "X9o9ESaJJ502" + }, + "outputs": [], + "source": [ + "normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))\n", + "image_batch, labels_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]\n", + "# Notice the pixels values are now in `[0,1]`.\n", + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XWEOmRSBJ9J8" + }, + "source": [ + "Or, you can include the layer inside your model definition, which can simplify deployment. Let's use the second approach here.\n", + "\n", + "Note: you previously resized images using the `image_size` argument of `image_dataset_from_directory`. If you want to include the resizing logic in your model as well, you can use the [Resizing](https://www.tensorflow.org/api_docs/python/tf/keras/layers/experimental/preprocessing/Resizing) layer." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WcUTyDOPKucd" + }, + "source": [ + "## Create the Model\n", + "\n", + "The model consists of three convolution blocks with a max pool layer in each of them. There's a fully connected layer with 128 units on top of it that is activated by a `relu` activation function. This model has not been tuned for high accuracy, the goal of this tutorial is to show a standard approach. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QR6argA1K074" + }, + "outputs": [], + "source": [ + "num_classes = 5\n", + "\n", + "model = Sequential([\n", + " layers.experimental.preprocessing.Rescaling(1./255, input_shape=(img_height, img_width, 3)),\n", + " layers.Conv2D(16, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(32, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(64, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Flatten(),\n", + " layers.Dense(128, activation='relu'),\n", + " layers.Dense(num_classes)\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EaKFzz72Lqpg" + }, + "source": [ + "## Compile the Model\n", + "\n", + "For this tutorial, choose the `optimizers.Adam` optimizer and `losses.SparseCategoricalCrossentropy` loss function. To view training and validation accuracy for each training epoch, pass the `metrics` argument." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jloGNS1MLx3A" + }, + "outputs": [], + "source": [ + "model.compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aMJ4DnuJL55A" + }, + "source": [ + "## Model Summary\n", + "\n", + "View all the layers of the network using the model's `summary` method.\n", + "\n", + "> **NOTE:** This section is commented out for performance reasons. Please feel free to uncomment these to compare the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "llLYH-BXL7Xe" + }, + "outputs": [], + "source": [ + "# model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NiYHcbvaL9H-" + }, + "source": [ + "## Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5fWToCqYMErH" + }, + "outputs": [], + "source": [ + "# epochs=10\n", + "# history = model.fit(\n", + "# train_ds,\n", + "# validation_data=val_ds,\n", + "# epochs=epochs\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dFvOvmAmMK9w" + }, + "source": [ + "## Visualize Training Results\n", + "\n", + "Create plots of loss and accuracy on the training and validation sets." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jWnopEChMMCn" + }, + "outputs": [], + "source": [ + "# acc = history.history['accuracy']\n", + "# val_acc = history.history['val_accuracy']\n", + "\n", + "# loss = history.history['loss']\n", + "# val_loss = history.history['val_loss']\n", + "\n", + "# epochs_range = range(epochs)\n", + "\n", + "# plt.figure(figsize=(8, 8))\n", + "# plt.subplot(1, 2, 1)\n", + "# plt.plot(epochs_range, acc, label='Training Accuracy')\n", + "# plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n", + "# plt.legend(loc='lower right')\n", + "# plt.title('Training and Validation Accuracy')\n", + "\n", + "# plt.subplot(1, 2, 2)\n", + "# plt.plot(epochs_range, loss, label='Training Loss')\n", + "# plt.plot(epochs_range, val_loss, label='Validation Loss')\n", + "# plt.legend(loc='upper right')\n", + "# plt.title('Training and Validation Loss')\n", + "# plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hO_jT7HwMrEn" + }, + "source": [ + "As you can see from the plots, training accuracy and validation accuracy are off by large margin and the model has achieved only around 60% accuracy on the validation set.\n", + "\n", + "Let's look at what went wrong and try to increase the overall performance of the model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ixsz9XFfMxcu" + }, + "source": [ + "## Overfitting\n", + "\n", + "In the plots above, the training accuracy is increasing linearly over time, whereas validation accuracy stalls around 60% in the training process. Also, the difference in accuracy between training and validation accuracy is noticeable — a sign of [overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit).\n", + "\n", + "When there are a small number of training examples, the model sometimes learns from noises or unwanted details from training examples—to an extent that it negatively impacts the performance of the model on new examples. This phenomenon is known as overfitting. It means that the model will have a difficult time generalizing on a new dataset.\n", + "\n", + "There are multiple ways to fight overfitting in the training process. In this tutorial, you'll use *data augmentation* and add *Dropout* to your model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GxYwix81M2YO" + }, + "source": [ + "## Data Augmentation\n", + "\n", + "Overfitting generally occurs when there are a small number of training examples. [Data augmentation](https://www.tensorflow.org/tutorials/images/data_augmentation) takes the approach of generating additional training data from your existing examples by augmenting them using random transformations that yield believable-looking images. This helps expose the model to more aspects of the data and generalize better.\n", + "\n", + "You will implement data augmentation using the layers from `tf.keras.layers.experimental.preprocessing`. These can be included inside your model like other layers, and run on the GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9J80BAbIMs21" + }, + "outputs": [], + "source": [ + "data_augmentation = keras.Sequential(\n", + " [\n", + " layers.experimental.preprocessing.RandomFlip(\"horizontal\", \n", + " input_shape=(img_height, \n", + " img_width,\n", + " 3)),\n", + " layers.experimental.preprocessing.RandomRotation(0.1),\n", + " layers.experimental.preprocessing.RandomZoom(0.1),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PN4k1dK3S6eV" + }, + "source": [ + "Let's visualize what a few augmented examples look like by applying data augmentation to the same image several times:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7Z90k539S838" + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images, _ in train_ds.take(1):\n", + " for i in range(9):\n", + " augmented_images = data_augmentation(images)\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(augmented_images[0].numpy().astype(\"uint8\"))\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tsjXCBLYYNs5" + }, + "source": [ + "You will use data augmentation to train a model in a moment." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZeD3bXepYKXs" + }, + "source": [ + "## Dropout\n", + "\n", + "Another technique to reduce overfitting is to introduce [Dropout](https://developers.google.com/machine-learning/glossary#dropout_regularization) to the network, a form of *regularization*.\n", + "\n", + "When you apply Dropout to a layer it randomly drops out (by setting the activation to zero) a number of output units from the layer during the training process. Dropout takes a fractional number as its input value, in the form such as 0.1, 0.2, 0.4, etc. This means dropping out 10%, 20% or 40% of the output units randomly from the applied layer.\n", + "\n", + "Let's create a new neural network using `layers.Dropout`, then train it using augmented images." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2Zeg8zsqXCsm" + }, + "outputs": [], + "source": [ + "model = Sequential([\n", + " data_augmentation,\n", + " layers.experimental.preprocessing.Rescaling(1./255),\n", + " layers.Conv2D(16, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(32, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Conv2D(64, 3, padding='same', activation='relu'),\n", + " layers.MaxPooling2D(),\n", + " layers.Dropout(0.2),\n", + " layers.Flatten(),\n", + " layers.Dense(128, activation='relu'),\n", + " layers.Dense(num_classes)\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L4nEcuqgZLbi" + }, + "source": [ + "## Compile and Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "EvyAINs9ZOmJ" + }, + "outputs": [], + "source": [ + "model.compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wWLkKoKjZSoC" + }, + "outputs": [], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PiAvrwo0tr6Z", + "tags": [], + "test_replace": { + "epochs = 15": "epochs = 1" + } + }, + "outputs": [], + "source": [ + "epochs = 15\n", + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=epochs\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Lkdl8VsBbZOu" + }, + "source": [ + "## Visualize Training Results\n", + "\n", + "After applying data augmentation and Dropout, there is less overfitting than before, and training and validation accuracy are closer aligned. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dduoLfKsZVIA" + }, + "outputs": [], + "source": [ + "acc = history.history['accuracy']\n", + "val_acc = history.history['val_accuracy']\n", + "\n", + "loss = history.history['loss']\n", + "val_loss = history.history['val_loss']\n", + "\n", + "epochs_range = range(epochs)\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(epochs_range, acc, label='Training Accuracy')\n", + "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n", + "plt.legend(loc='lower right')\n", + "plt.title('Training and Validation Accuracy')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(epochs_range, loss, label='Training Loss')\n", + "plt.plot(epochs_range, val_loss, label='Validation Loss')\n", + "plt.legend(loc='upper right')\n", + "plt.title('Training and Validation Loss')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dtv5VbaVb-3W" + }, + "source": [ + "## Predict on New Data\n", + "\n", + "Finally, let's use our model to classify an image that wasn't included in the training or validation sets.\n", + "\n", + "Note: Data augmentation and Dropout layers are inactive at inference time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dC40sRITBSsQ", + "tags": [] + }, + "outputs": [], + "source": [ + "sunflower_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg\"\n", + "sunflower_path = tf.keras.utils.get_file('Red_sunflower', origin=sunflower_url)\n", + "\n", + "img = keras.preprocessing.image.load_img(\n", + " sunflower_path, target_size=(img_height, img_width)\n", + ")\n", + "img_array = keras.preprocessing.image.img_to_array(img)\n", + "img_array = tf.expand_dims(img_array, 0) # Create a batch\n", + "\n", + "predictions = model.predict(img_array)\n", + "score = tf.nn.softmax(predictions[0])\n", + "\n", + "print(\n", + " \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n", + " .format(class_names[np.argmax(score)], 100 * np.max(score))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Save the TensorFlow Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#save the trained model - a new folder flower will be created\n", + "#and the file \"saved_model.pb\" is the pre-trained model\n", + "model_dir = \"model\"\n", + "model_fname = f\"{model_dir}/flower\"\n", + "model.save(model_fname)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Convert the TensorFlow model with OpenVINO Model Optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The paths of the source and converted models\n", + "model_name = \"flower\"\n", + "model_path = Path(model_fname)\n", + "ir_data_type = \"FP16\"\n", + "ir_model_name = \"flower_ir\"\n", + "\n", + "# Get the path to the Model Optimizer script\n", + "\n", + "# Construct the command for Model Optimizer\n", + "mo_command = f\"\"\"mo \n", + " --saved_model_dir \"{model_fname}\"\n", + " --input_shape \"[1,180,180,3]\" \n", + " --data_type \"{ir_data_type}\" \n", + " --output_dir \"{model_fname}\"\n", + " --model_name \"{ir_model_name}\"\n", + " \"\"\"\n", + "mo_command = \" \".join(mo_command.split())\n", + "print(\"Model Optimizer command to convert TensorFlow to OpenVINO:\")\n", + "print(mo_command)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the Model Optimizer (overwrites the older model)\n", + "print(\"Exporting TensorFlow model to IR... This may take a few minutes.\")\n", + "mo_result = %sx $mo_command\n", + "print(\"\\n\".join(mo_result))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preprocessing Image Function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def pre_process_image(imagePath, img_height=180):\n", + " # Model input format\n", + " n, h, w, c = [1, img_height, img_height, 3]\n", + " image = Image.open(imagePath)\n", + " image = image.resize((h, w), resample=Image.BILINEAR)\n", + "\n", + " # Convert to array and change data layout from HWC to CHW\n", + " image = np.array(image)\n", + " input_image = image.reshape((n, h, w, c))\n", + "\n", + " return input_image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## OpenVINO Inference Engine Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class_names=[\"daisy\", \"dandelion\", \"roses\", \"sunflowers\", \"tulips\"]\n", + "\n", + "model_xml = f\"{model_fname}/flower_ir.xml\"\n", + "\n", + "# Load model\n", + "ie = Core()\n", + "model = ie.read_model(model=model_xml)\n", + "\n", + "# Neural Compute Stick\n", + "# compiled_model = ie.compile_model(model=model, device_name=\"MYRIAD\")\n", + "compiled_model = ie.compile_model(model=model, device_name=\"CPU\")\n", + "\n", + "del model\n", + "\n", + "input_layer = compiled_model.input(0)\n", + "output_layer = compiled_model.output(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the Inference Step" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run inference on the input image...\n", + "inp_img_url = \"https://upload.wikimedia.org/wikipedia/commons/4/48/A_Close_Up_Photo_of_a_Dandelion.jpg\"\n", + "OUTPUT_DIR = \"output\"\n", + "inp_file_name = f\"A_Close_Up_Photo_of_a_Dandelion.jpg\"\n", + "file_path = Path(OUTPUT_DIR)/Path(inp_file_name)\n", + "\n", + "os.makedirs(OUTPUT_DIR, exist_ok=True)\n", + "\n", + "# Download the image\n", + "download_file(inp_img_url, inp_file_name, directory=OUTPUT_DIR)\n", + "\n", + "# Pre-process the image and get it ready for inference.\n", + "input_image = pre_process_image(file_path)\n", + "\n", + "print(input_image.shape)\n", + "print(input_layer.shape)\n", + "res = compiled_model([input_image])[output_layer]\n", + "\n", + "score = tf.nn.softmax(res[0])\n", + "\n", + "# Show the results\n", + "image = Image.open(file_path)\n", + "plt.imshow(image)\n", + "print(\n", + " \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n", + " .format(class_names[np.argmax(score)], 100 * np.max(score))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## The Next Steps\n", + "\n", + "This tutorial showed how to train a TensorFlow model, how to convert that model to OpenVINO's IR format, and how to do inference on the converted model. For faster inference speed, you can quantize the IR model. To see how to quantize this model with OpenVINO's [Post-Training Optimization Tool](https://docs.openvino.ai/2021.4/pot_README.html), check out the [Post-Training Quantization with TensorFlow Classification Model](./301-tensorflow-training-openvino-pot.ipynb) notebook." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "classification.ipynb", + "toc_visible": true + }, + "interpreter": { + "hash": "8e25c8ed6cc2cfe6c8620be5042bb64fac4c236f57496fb5eb68e9ea1795f1fe" + }, + "kernelspec": { + "display_name": "openvino_env", + "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.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/session_4/notebooks/model/flower/flower_ir.bin b/session_4/notebooks/model/flower/flower_ir.bin new file mode 100644 index 0000000..2126a9a Binary files /dev/null and b/session_4/notebooks/model/flower/flower_ir.bin differ diff --git a/session_4/notebooks/model/flower/flower_ir.mapping b/session_4/notebooks/model/flower/flower_ir.mapping new file mode 100644 index 0000000..8f2f4e7 --- /dev/null +++ b/session_4/notebooks/model/flower/flower_ir.mapping @@ -0,0 +1,143 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_4/notebooks/model/flower/flower_ir.xml b/session_4/notebooks/model/flower/flower_ir.xml new file mode 100644 index 0000000..1c23f19 --- /dev/null +++ b/session_4/notebooks/model/flower/flower_ir.xml @@ -0,0 +1,877 @@ + + + + + + + + + + + + 1 + 180 + 180 + 3 + + + + + + + + 4 + + + + + + + 1 + 180 + 180 + 3 + + + 4 + + + + + 1 + 3 + 180 + 180 + + + + + + + + 16 + 3 + 3 + 3 + + + + + + + + + + + 16 + 3 + 3 + 3 + + + + + 16 + 3 + 3 + 3 + + + + + + + + 1 + 3 + 180 + 180 + + + 16 + 3 + 3 + 3 + + + + + 1 + 16 + 180 + 180 + + + + + + + + 1 + 16 + 1 + 1 + + + + + + + + + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 1 + 1 + + + + + + + + 1 + 16 + 180 + 180 + + + 1 + 16 + 1 + 1 + + + + + 1 + 16 + 180 + 180 + + + + + + + 1 + 16 + 180 + 180 + + + + + 1 + 16 + 180 + 180 + + + + + + + + 1 + 16 + 180 + 180 + + + + + 1 + 16 + 90 + 90 + + + 1 + 16 + 90 + 90 + + + + + + + + 32 + 16 + 3 + 3 + + + + + + + + + + + 32 + 16 + 3 + 3 + + + + + 32 + 16 + 3 + 3 + + + + + + + + 1 + 16 + 90 + 90 + + + 32 + 16 + 3 + 3 + + + + + 1 + 32 + 90 + 90 + + + + + + + + 1 + 32 + 1 + 1 + + + + + + + + + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 1 + 1 + + + + + + + + 1 + 32 + 90 + 90 + + + 1 + 32 + 1 + 1 + + + + + 1 + 32 + 90 + 90 + + + + + + + 1 + 32 + 90 + 90 + + + + + 1 + 32 + 90 + 90 + + + + + + + + 1 + 32 + 90 + 90 + + + + + 1 + 32 + 45 + 45 + + + 1 + 32 + 45 + 45 + + + + + + + + 64 + 32 + 3 + 3 + + + + + + + + + + + 64 + 32 + 3 + 3 + + + + + 64 + 32 + 3 + 3 + + + + + + + + 1 + 32 + 45 + 45 + + + 64 + 32 + 3 + 3 + + + + + 1 + 64 + 45 + 45 + + + + + + + + 1 + 64 + 1 + 1 + + + + + + + + + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 1 + 1 + + + + + + + + 1 + 64 + 45 + 45 + + + 1 + 64 + 1 + 1 + + + + + 1 + 64 + 45 + 45 + + + + + + + 1 + 64 + 45 + 45 + + + + + 1 + 64 + 45 + 45 + + + + + + + + 1 + 64 + 45 + 45 + + + + + 1 + 64 + 22 + 22 + + + 1 + 64 + 22 + 22 + + + + + + + + 4 + + + + + + + 1 + 64 + 22 + 22 + + + 4 + + + + + 1 + 22 + 22 + 64 + + + + + + + + 2 + + + + + + + + 1 + 22 + 22 + 64 + + + 2 + + + + + 1 + 30976 + + + + + + + + 128 + 30976 + + + + + + + + + + + 128 + 30976 + + + + + 128 + 30976 + + + + + + + + 1 + 30976 + + + 128 + 30976 + + + + + 1 + 128 + + + + + + + + 1 + 128 + + + + + + + + + + + 1 + 128 + + + + + 1 + 128 + + + + + + + + 1 + 128 + + + 1 + 128 + + + + + 1 + 128 + + + + + + + 1 + 128 + + + + + 1 + 128 + + + + + + + + 5 + 128 + + + + + + + + + + + 5 + 128 + + + + + 5 + 128 + + + + + + + + 1 + 128 + + + 5 + 128 + + + + + 1 + 5 + + + + + + + + 1 + 5 + + + + + + + + + + + 1 + 5 + + + + + 1 + 5 + + + + + + + + 1 + 5 + + + 1 + 5 + + + + + 1 + 5 + + + + + + + 1 + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/session_4/notebooks/model/flower/keras_metadata.pb b/session_4/notebooks/model/flower/keras_metadata.pb new file mode 100644 index 0000000..ca79519 --- /dev/null +++ b/session_4/notebooks/model/flower/keras_metadata.pb @@ -0,0 +1,20 @@ + +droot"_tf_keras_sequential*d{"name": "sequential_2", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "must_restore_from_config": false, "class_name": "Sequential", "config": {"name": "sequential_2", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "sequential_1_input"}}, {"class_name": "Sequential", "config": {"name": "sequential_1", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_input"}}, {"class_name": "RandomFlip", "config": {"name": "random_flip", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}}, {"class_name": "RandomRotation", "config": {"name": "random_rotation", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}, {"class_name": "RandomZoom", "config": {"name": "random_zoom", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}]}}, {"class_name": "Rescaling", "config": {"name": "rescaling_2", "trainable": true, "dtype": "float32", "scale": 0.00392156862745098, "offset": 0.0}}, {"class_name": "Conv2D", "config": {"name": "conv2d_3", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_3", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}}, {"class_name": "Conv2D", "config": {"name": "conv2d_4", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_4", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}}, {"class_name": "Conv2D", "config": {"name": "conv2d_5", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_5", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}}, {"class_name": "Dropout", "config": {"name": "dropout", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}}, {"class_name": "Flatten", "config": {"name": "flatten_1", "trainable": true, "dtype": "float32", "data_format": "channels_last"}}, {"class_name": "Dense", "config": {"name": "dense_2", "trainable": true, "dtype": "float32", "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Dense", "config": {"name": "dense_3", "trainable": true, "dtype": "float32", "units": 5, "activation": "linear", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}]}, "shared_object_id": 27, "input_spec": [{"class_name": "InputSpec", "config": {"dtype": null, "shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}}], "build_input_shape": {"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "is_graph_network": true, "full_save_spec": {"class_name": "__tuple__", "items": [[{"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "sequential_1_input"]}], {}]}, "save_spec": {"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "sequential_1_input"]}, "keras_version": "2.9.0", "backend": "tensorflow", "model_config": {"class_name": "Sequential", "config": {"name": "sequential_2", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "sequential_1_input"}, "shared_object_id": 0}, {"class_name": "Sequential", "config": {"name": "sequential_1", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_input"}}, {"class_name": "RandomFlip", "config": {"name": "random_flip", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}}, {"class_name": "RandomRotation", "config": {"name": "random_rotation", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}, {"class_name": "RandomZoom", "config": {"name": "random_zoom", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}]}, "shared_object_id": 5}, {"class_name": "Rescaling", "config": {"name": "rescaling_2", "trainable": true, "dtype": "float32", "scale": 0.00392156862745098, "offset": 0.0}, "shared_object_id": 6}, {"class_name": "Conv2D", "config": {"name": "conv2d_3", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 7}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 8}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 9}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_3", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 10}, {"class_name": "Conv2D", "config": {"name": "conv2d_4", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 11}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 12}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 13}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_4", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 14}, {"class_name": "Conv2D", "config": {"name": "conv2d_5", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 15}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 16}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 17}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_5", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 18}, {"class_name": "Dropout", "config": {"name": "dropout", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "shared_object_id": 19}, {"class_name": "Flatten", "config": {"name": "flatten_1", "trainable": true, "dtype": "float32", "data_format": "channels_last"}, "shared_object_id": 20}, {"class_name": "Dense", "config": {"name": "dense_2", "trainable": true, "dtype": "float32", "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 21}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 22}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 23}, {"class_name": "Dense", "config": {"name": "dense_3", "trainable": true, "dtype": "float32", "units": 5, "activation": "linear", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 24}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 25}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 26}]}}, "training_config": {"loss": {"class_name": "SparseCategoricalCrossentropy", "config": {"reduction": "auto", "name": "sparse_categorical_crossentropy", "from_logits": true}, "shared_object_id": 29}, "metrics": [[{"class_name": "MeanMetricWrapper", "config": {"name": "accuracy", "dtype": "float32", "fn": "sparse_categorical_accuracy"}, "shared_object_id": 30}]], "weighted_metrics": null, "loss_weights": null, "optimizer_config": {"class_name": "Adam", "config": {"name": "Adam", "learning_rate": 0.0010000000474974513, "decay": 0.0, "beta_1": 0.8999999761581421, "beta_2": 0.9990000128746033, "epsilon": 1e-07, "amsgrad": false}}}}2 + root.layer-0"_tf_keras_sequential*{"name": "sequential_1", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "must_restore_from_config": false, "class_name": "Sequential", "config": {"name": "sequential_1", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_input"}}, {"class_name": "RandomFlip", "config": {"name": "random_flip", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}}, {"class_name": "RandomRotation", "config": {"name": "random_rotation", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}, {"class_name": "RandomZoom", "config": {"name": "random_zoom", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}}]}, "shared_object_id": 5, "input_spec": [{"class_name": "InputSpec", "config": {"dtype": null, "shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}}], "build_input_shape": {"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "is_graph_network": true, "full_save_spec": {"class_name": "__tuple__", "items": [[{"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "random_flip_input"]}], {}]}, "save_spec": {"class_name": "TypeSpec", "type_spec": "tf.TensorSpec", "serialized": [{"class_name": "TensorShape", "items": [null, 180, 180, 3]}, "float32", "random_flip_input"]}, "keras_version": "2.9.0", "backend": "tensorflow", "model_config": {"class_name": "Sequential", "config": {"name": "sequential_1", "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "sparse": false, "ragged": false, "name": "random_flip_input"}, "shared_object_id": 1}, {"class_name": "RandomFlip", "config": {"name": "random_flip", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}, "shared_object_id": 2}, {"class_name": "RandomRotation", "config": {"name": "random_rotation", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 3}, {"class_name": "RandomZoom", "config": {"name": "random_zoom", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 4}]}}}2 + root.layer-1"_tf_keras_layer*{"name": "rescaling_2", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Rescaling", "config": {"name": "rescaling_2", "trainable": true, "dtype": "float32", "scale": 0.00392156862745098, "offset": 0.0}, "shared_object_id": 6}2 + root.layer_with_weights-0"_tf_keras_layer* {"name": "conv2d_3", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Conv2D", "config": {"name": "conv2d_3", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 7}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 8}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 9, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 4, "axes": {"-1": 3}}, "shared_object_id": 32}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 180, 180, 3]}}2 + root.layer-3"_tf_keras_layer*{"name": "max_pooling2d_3", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_3", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 10, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}, "shared_object_id": 33}}2 + root.layer_with_weights-1"_tf_keras_layer* {"name": "conv2d_4", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Conv2D", "config": {"name": "conv2d_4", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 11}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 12}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 13, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 4, "axes": {"-1": 16}}, "shared_object_id": 34}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 90, 90, 16]}}2 + root.layer-5"_tf_keras_layer*{"name": "max_pooling2d_4", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_4", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 14, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}, "shared_object_id": 35}}2 + root.layer_with_weights-2"_tf_keras_layer* {"name": "conv2d_5", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Conv2D", "config": {"name": "conv2d_5", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": {"class_name": "__tuple__", "items": [3, 3]}, "strides": {"class_name": "__tuple__", "items": [1, 1]}, "padding": "same", "data_format": "channels_last", "dilation_rate": {"class_name": "__tuple__", "items": [1, 1]}, "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 15}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 16}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 17, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 4, "axes": {"-1": 32}}, "shared_object_id": 36}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 45, 45, 32]}}2 + root.layer-7"_tf_keras_layer*{"name": "max_pooling2d_5", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_5", "trainable": true, "dtype": "float32", "pool_size": {"class_name": "__tuple__", "items": [2, 2]}, "padding": "valid", "strides": {"class_name": "__tuple__", "items": [2, 2]}, "data_format": "channels_last"}, "shared_object_id": 18, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": 4, "max_ndim": null, "min_ndim": null, "axes": {}}, "shared_object_id": 37}}2 +  root.layer-8"_tf_keras_layer*{"name": "dropout", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Dropout", "config": {"name": "dropout", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "shared_object_id": 19, "build_input_shape": {"class_name": "TensorShape", "items": [null, 22, 22, 64]}}2 + + root.layer-9"_tf_keras_layer*{"name": "flatten_1", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Flatten", "config": {"name": "flatten_1", "trainable": true, "dtype": "float32", "data_format": "channels_last"}, "shared_object_id": 20, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 1, "axes": {}}, "shared_object_id": 38}}2 + root.layer_with_weights-3"_tf_keras_layer*{"name": "dense_2", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Dense", "config": {"name": "dense_2", "trainable": true, "dtype": "float32", "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 21}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 22}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 23, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 2, "axes": {"-1": 30976}}, "shared_object_id": 39}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 30976]}}2 + root.layer_with_weights-4"_tf_keras_layer*{"name": "dense_3", "trainable": true, "expects_training_arg": false, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "Dense", "config": {"name": "dense_3", "trainable": true, "dtype": "float32", "units": 5, "activation": "linear", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}, "shared_object_id": 24}, "bias_initializer": {"class_name": "Zeros", "config": {}, "shared_object_id": 25}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "shared_object_id": 26, "input_spec": {"class_name": "InputSpec", "config": {"dtype": null, "shape": null, "ndim": null, "max_ndim": null, "min_ndim": 2, "axes": {"-1": 128}}, "shared_object_id": 40}, "build_input_shape": {"class_name": "TensorShape", "items": [null, 128]}}2 +root.layer-0.layer-0"_tf_keras_layer*{"name": "random_flip", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "stateful": false, "must_restore_from_config": false, "class_name": "RandomFlip", "config": {"name": "random_flip", "trainable": true, "batch_input_shape": {"class_name": "__tuple__", "items": [null, 180, 180, 3]}, "dtype": "float32", "mode": "horizontal", "seed": null}, "shared_object_id": 2}2 +root.layer-0.layer-1"_tf_keras_layer*{"name": "random_rotation", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "RandomRotation", "config": {"name": "random_rotation", "trainable": true, "dtype": "float32", "factor": 0.1, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 3}2 +root.layer-0.layer-2"_tf_keras_layer*{"name": "random_zoom", "trainable": true, "expects_training_arg": true, "dtype": "float32", "batch_input_shape": null, "stateful": false, "must_restore_from_config": false, "class_name": "RandomZoom", "config": {"name": "random_zoom", "trainable": true, "dtype": "float32", "height_factor": 0.1, "width_factor": null, "fill_mode": "reflect", "fill_value": 0.0, "interpolation": "bilinear", "seed": null}, "shared_object_id": 4}2 +root.keras_api.metrics.0"_tf_keras_metric*{"class_name": "Mean", "name": "loss", "dtype": "float32", "config": {"name": "loss", "dtype": "float32"}, "shared_object_id": 41}2 +root.keras_api.metrics.1"_tf_keras_metric*{"class_name": "MeanMetricWrapper", "name": "accuracy", "dtype": "float32", "config": {"name": "accuracy", "dtype": "float32", "fn": "sparse_categorical_accuracy"}, "shared_object_id": 30}2 \ No newline at end of file diff --git a/session_4/notebooks/model/flower/saved_model.pb b/session_4/notebooks/model/flower/saved_model.pb new file mode 100644 index 0000000..9eba531 Binary files /dev/null and b/session_4/notebooks/model/flower/saved_model.pb differ diff --git a/session_4/notebooks/model/flower/variables/variables.data-00000-of-00001 b/session_4/notebooks/model/flower/variables/variables.data-00000-of-00001 new file mode 100644 index 0000000..7d6844e Binary files /dev/null and b/session_4/notebooks/model/flower/variables/variables.data-00000-of-00001 differ diff --git a/session_4/notebooks/model/flower/variables/variables.index b/session_4/notebooks/model/flower/variables/variables.index new file mode 100644 index 0000000..3feba88 Binary files /dev/null and b/session_4/notebooks/model/flower/variables/variables.index differ diff --git a/session_4/notebooks/output/A_Close_Up_Photo_of_a_Dandelion.jpg b/session_4/notebooks/output/A_Close_Up_Photo_of_a_Dandelion.jpg new file mode 100644 index 0000000..918f458 Binary files /dev/null and b/session_4/notebooks/output/A_Close_Up_Photo_of_a_Dandelion.jpg differ diff --git a/session_4/utils/async_pipeline.py b/session_4/utils/async_pipeline.py new file mode 100644 index 0000000..20eb275 --- /dev/null +++ b/session_4/utils/async_pipeline.py @@ -0,0 +1,154 @@ +""" + Copyright (C) 2020 Intel Corporation + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +""" + +import logging +import threading +from collections import deque +from typing import Dict, Set +from pathlib import Path + + +def parse_devices(device_string): + colon_position = device_string.find(':') + if colon_position != -1: + device_type = device_string[:colon_position] + if device_type == 'HETERO' or device_type == 'MULTI': + comma_separated_devices = device_string[colon_position + 1:] + devices = comma_separated_devices.split(',') + for device in devices: + parenthesis_position = device.find(':') + if parenthesis_position != -1: + device = device[:parenthesis_position] + return devices + return (device_string,) + + +def parse_value_per_device(devices: Set[str], values_string: str)-> Dict[str, int]: + """Format: :,: or just """ + values_string_upper = values_string.upper() + result = {} + device_value_strings = values_string_upper.split(',') + for device_value_string in device_value_strings: + device_value_list = device_value_string.split(':') + if len(device_value_list) == 2: + if device_value_list[0] in devices: + result[device_value_list[0]] = int(device_value_list[1]) + elif len(device_value_list) == 1 and device_value_list[0] != '': + for device in devices: + result[device] = int(device_value_list[0]) + elif device_value_list[0] != '': + raise RuntimeError(f'Unknown string format: {values_string}') + return result + + +def get_user_config(flags_d: str, flags_nstreams: str, flags_nthreads: int)-> Dict[str, str]: + config = {} + + devices = set(parse_devices(flags_d)) + + device_nstreams = parse_value_per_device(devices, flags_nstreams) + for device in devices: + if device == 'CPU': # CPU supports a few special performance-oriented keys + # limit threading for CPU portion of inference + if flags_nthreads: + config['CPU_THREADS_NUM'] = str(flags_nthreads) + + config['CPU_BIND_THREAD'] = 'NO' + + # for CPU execution, more throughput-oriented execution via streams + config['CPU_THROUGHPUT_STREAMS'] = str(device_nstreams[device]) \ + if device in device_nstreams else 'CPU_THROUGHPUT_AUTO' + elif device == 'GPU': + config['GPU_THROUGHPUT_STREAMS'] = str(device_nstreams[device]) \ + if device in device_nstreams else 'GPU_THROUGHPUT_AUTO' + if 'MULTI' in flags_d and 'CPU' in devices: + # multi-device execution with the CPU + GPU performs best with GPU throttling hint, + # which releases another CPU thread (that is otherwise used by the GPU driver for active polling) + config['GPU_PLUGIN_THROTTLE'] = '1' + return config + + +class AsyncPipeline: + def __init__(self, ie, model, plugin_config, device='CPU', max_num_requests=0): + cache_path = Path("model_cache") + cache_path.mkdir(exist_ok=True) + # Enable model cachine for GPU devices + if "GPU" in device and "GPU" in ie.available_devices: + ie.set_config({"CACHE_DIR": str(cache_path)}, device_name="GPU") + + self.model = model + self.logger = logging.getLogger() + + self.logger.info('Loading network to {} plugin...'.format(device)) + self.exec_net = ie.load_network(network=self.model.net, device_name=device, + config=plugin_config, num_requests=max_num_requests) + if max_num_requests == 0: + # ExecutableNetwork doesn't allow creation of additional InferRequests. Reload ExecutableNetwork + # +1 to use it as a buffer of the pipeline + self.exec_net = ie.load_network(network=self.model.net, device_name=device, + config=plugin_config, num_requests=len(self.exec_net.requests) + 1) + + self.empty_requests = deque(self.exec_net.requests) + self.completed_request_results = {} + self.callback_exceptions = {} + self.event = threading.Event() + + def inference_completion_callback(self, status, callback_args): + try: + request, id, meta, preprocessing_meta = callback_args + if status != 0: + raise RuntimeError('Infer Request has returned status code {}'.format(status)) + raw_outputs = {key: blob.buffer for key, blob in request.output_blobs.items()} + self.completed_request_results[id] = (raw_outputs, meta, preprocessing_meta) + self.empty_requests.append(request) + except Exception as e: + self.callback_exceptions.append(e) + self.event.set() + + def submit_data(self, inputs, id, meta): + request = self.empty_requests.popleft() + if len(self.empty_requests) == 0: + self.event.clear() + inputs, preprocessing_meta = self.model.preprocess(inputs) + request.set_completion_callback(py_callback=self.inference_completion_callback, + py_data=(request, id, meta, preprocessing_meta)) + request.async_infer(inputs=inputs) + + def get_raw_result(self, id): + if id in self.completed_request_results: + return self.completed_request_results.pop(id) + return None + + def get_result(self, id): + result = self.get_raw_result(id) + if result: + raw_result, meta, preprocess_meta = result + return self.model.postprocess(raw_result, preprocess_meta), meta + return None + + def is_ready(self): + return len(self.empty_requests) != 0 + + def has_completed_request(self): + return len(self.completed_request_results) != 0 + + def await_all(self): + for request in self.exec_net.requests: + request.wait() + + def await_any(self): + if len(self.empty_requests) == 0: + self.event.wait() diff --git a/session_4/utils/notebook_utils.ipynb b/session_4/utils/notebook_utils.ipynb new file mode 100644 index 0000000..deaec04 --- /dev/null +++ b/session_4/utils/notebook_utils.ipynb @@ -0,0 +1,1371 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e0ae5969", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "# Notebook Utils\n", + "\n", + "This notebook contains helper functions and classes for use with OpenVINO™ Notebooks. The code is synchronized with the `notebook_utils.py` file in the same directory as this notebook.\n", + "\n", + "There are five categories:\n", + "\n", + "- [Files](#Files)\n", + "- [Images](#Images)\n", + "- [Videos](#Videos)\n", + "- [Visualization](#Visualization)\n", + "- [OpenVINO Tools](#OpenVINO-Tools)\n", + "- [Checks and Alerts](#Checks-and-Alerts)\n", + "\n", + "Each category contains a test cell that also shows how to use the functions in the section. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "610d8c96", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import shutil\n", + "import socket\n", + "import threading\n", + "import time\n", + "import urllib\n", + "import urllib.parse\n", + "import urllib.request\n", + "from os import PathLike\n", + "from pathlib import Path\n", + "from typing import Callable, List, NamedTuple, Optional, Tuple\n", + "\n", + "import cv2\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import openvino.inference_engine\n", + "from async_pipeline import AsyncPipeline\n", + "from IPython.display import HTML, Image, Markdown, clear_output, display\n", + "from matplotlib.lines import Line2D\n", + "from models import model\n", + "from openvino.inference_engine import IECore\n", + "from tqdm.notebook import tqdm_notebook" + ] + }, + { + "cell_type": "markdown", + "id": "9e8b4817", + "metadata": {}, + "source": [ + "## Files\n", + "\n", + "Load an image, download a file, download an OpenVINO IR model, and create a progress bar to show download progress." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1584d210", + "metadata": {}, + "outputs": [], + "source": [ + "def load_image(path: str) -> np.ndarray:\n", + " \"\"\"\n", + " Loads an image from `path` and returns it as BGR numpy array. The `path` variable\n", + " should point to an image file, either a local filename or a url. The image is\n", + " not stored to the filesystem. Use the `download_file` function to download and\n", + " store an image.\n", + "\n", + " :param path: Local path name or URL to image.\n", + " :return: image as BGR numpy array\n", + " \"\"\"\n", + " if path.startswith(\"http\"):\n", + " # Set User-Agent to Mozilla because some websites block\n", + " # requests with User-Agent Python.\n", + " request = urllib.request.Request(path, headers={\"User-Agent\": \"Mozilla/5.0\"})\n", + " response = urllib.request.urlopen(request)\n", + " array = np.asarray(bytearray(response.read()), dtype=\"uint8\")\n", + " image = cv2.imdecode(array, -1) # Loads the image as BGR.\n", + " else:\n", + " image = cv2.imread(path)\n", + " return image\n", + "\n", + "\n", + "class DownloadProgressBar(tqdm_notebook):\n", + " \"\"\"\n", + " TQDM Progress bar for downloading files with urllib.request.urlretrieve\n", + " \"\"\"\n", + "\n", + " def update_to(self, block_num: int, block_size: int, total_size: int):\n", + " downloaded = block_num * block_size\n", + " if downloaded <= total_size:\n", + " self.update(downloaded - self.n)\n", + "\n", + "\n", + "def download_file(\n", + " url: PathLike,\n", + " filename: PathLike = None,\n", + " directory: PathLike = None,\n", + " show_progress: bool = True,\n", + " silent: bool = False,\n", + " timeout: int = 10,\n", + ") -> str:\n", + " \"\"\"\n", + " Download a file from a url and save it to the local filesystem. The file is saved to the\n", + " current directory by default, or to `directory` if specified. If a filename is not given,\n", + " the filename of the URL will be used.\n", + "\n", + " :param url: URL that points to the file to download.\n", + " :param filename: A name of the local file to save. It should point to the name of the file only,\n", + " not the full path. If set to None, the filename from the url will be used\n", + " :param directory: A directory to save the file to. It will be created if it does not exist\n", + " If set to None, the file will be saved to the current working directory.\n", + " :param show_progress: If set to True, shows an TQDM ProgressBar.\n", + " :param silent: If set to True, does not print a message if the file already exists.\n", + " :param timeout: number of seconds before cancelling the connection attempt\n", + " :return: path to downloaded file\n", + " \"\"\"\n", + " try:\n", + " opener = urllib.request.build_opener()\n", + " opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", + " urllib.request.install_opener(opener)\n", + " urlobject = urllib.request.urlopen(url, timeout=timeout)\n", + " if filename is None:\n", + " filename = urlobject.info().get_filename() or Path(urllib.parse.urlparse(url).path).name\n", + " except urllib.error.HTTPError as e:\n", + " raise Exception(f\"File downloading failed with error: {e.code} {e.msg}\") from None\n", + " except urllib.error.URLError as error:\n", + " if isinstance(error.reason, socket.timeout):\n", + " raise Exception(\n", + " \"Connection timed out. If you access the internet through a proxy server, \"\n", + " \"make sure the proxy is set in the shell from where you launched Jupyter. If your \"\n", + " \"internet connection is slow, you can call `download_file(url, timeout=30)` to \"\n", + " \"wait for 30 seconds before raising this error.\"\n", + " ) from None\n", + " else:\n", + " raise\n", + "\n", + " filename = Path(filename)\n", + " if len(filename.parts) > 1:\n", + " raise ValueError(\n", + " \"The `filename` parameter should refer to the name of the file, excluding the directory. \"\n", + " \"Use the `directory` parameter to specify a target directory for the downloaded file.\"\n", + " )\n", + "\n", + " # Create the directory if it does not exist, and add the directory to the filename.\n", + " if directory is not None:\n", + " directory = Path(directory)\n", + " directory.mkdir(parents=True, exist_ok=True)\n", + " filename = directory / Path(filename)\n", + "\n", + " # Download the file if it does not exist, or if it exists with an incorrect file size.\n", + " urlobject_size = int(urlobject.info().get(\"Content-Length\", 0))\n", + " if not filename.exists() or (os.stat(filename).st_size != urlobject_size):\n", + " progress_callback = DownloadProgressBar(\n", + " total=urlobject_size,\n", + " unit=\"B\",\n", + " unit_scale=True,\n", + " unit_divisor=1024,\n", + " desc=str(filename),\n", + " disable=not show_progress,\n", + " )\n", + " urllib.request.urlretrieve(url, filename, reporthook=progress_callback.update_to)\n", + " if os.stat(filename).st_size >= urlobject_size:\n", + " progress_callback.update(urlobject_size - progress_callback.n)\n", + " progress_callback.refresh()\n", + " else:\n", + " if not silent:\n", + " print(f\"'{filename}' already exists.\")\n", + " return filename.resolve()\n", + "\n", + "\n", + "def download_ir_model(model_xml_url: str, destination_folder: PathLike = None) -> PathLike:\n", + " \"\"\"\n", + " Download OpenVINO IR model from `model_xml_url`. Downloads xml and bin file of the model; the weights file is\n", + " assumed to exist at the same location and name as `model_xml_url` with a \".bin\" extension.\n", + "\n", + " :param model_xml_url: The URL to xml file of the model to download.\n", + " :param destination_folder: A directory where downloaded xml and bin files of the model are saved. If set to None, model\n", + " files are saved to the current directory.\n", + " :return: The path to downloaded xml file of the model.\n", + " \"\"\"\n", + " model_bin_url = model_xml_url[:-4] + \".bin\"\n", + " model_xml_path = download_file(model_xml_url, directory=destination_folder, show_progress=False)\n", + " download_file(model_bin_url, directory=destination_folder)\n", + " return model_xml_path" + ] + }, + { + "cell_type": "markdown", + "id": "407d4219", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test File Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa1a0ee0", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "model_url = \"https://github.com/openvinotoolkit/openvino_notebooks/raw/main/notebooks/002-openvino-api/model/segmentation.xml\"\n", + "download_ir_model(model_url, \"model\")\n", + "\n", + "assert os.path.exists(\"model/segmentation.xml\")\n", + "assert os.path.exists(\"model/segmentation.bin\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51392a8e", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "url = \"https://github.com/intel-iot-devkit/safety-gear-detector-python/raw/master/resources/Safety_Full_Hat_and_Vest.mp4\"\n", + "if os.path.exists(os.path.basename(url)):\n", + " os.remove(os.path.basename(url))\n", + "video_file = download_file(url)\n", + "print(video_file)\n", + "assert Path(video_file).exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46478651", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "url = \"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/README.md\"\n", + "filename = \"openvino_notebooks_readme.md\"\n", + "if os.path.exists(filename):\n", + " os.remove(filename)\n", + "readme_file = download_file(url, filename=filename)\n", + "print(readme_file)\n", + "assert Path(readme_file).exists()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d15056b5", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "url = \"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/README.md\"\n", + "filename = \"openvino_notebooks_readme.md\"\n", + "directory = \"temp\"\n", + "video_file = download_file(\n", + " url, filename=filename, directory=directory, show_progress=False, silent=True\n", + ")\n", + "print(readme_file)\n", + "assert Path(readme_file).exists()\n", + "shutil.rmtree(\"temp\")" + ] + }, + { + "cell_type": "markdown", + "id": "b6f5caa5", + "metadata": {}, + "source": [ + "## Images" + ] + }, + { + "cell_type": "markdown", + "id": "9c45916c", + "metadata": {}, + "source": [ + "### Convert Pixel Data\n", + "\n", + "Normalize image pixel values between 0 and 1, and convert images to `RGB` and `BGR`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4051c7ef", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_minmax(data):\n", + " \"\"\"\n", + " Normalizes the values in `data` between 0 and 1\n", + " \"\"\"\n", + " if data.max() == data.min():\n", + " raise ValueError(\n", + " \"Normalization is not possible because all elements of\"\n", + " f\"`data` have the same value: {data.max()}.\"\n", + " )\n", + " return (data - data.min()) / (data.max() - data.min())\n", + "\n", + "\n", + "def to_rgb(image_data: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " Convert image_data from BGR to RGB.\n", + " \"\"\"\n", + " return cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB)\n", + "\n", + "\n", + "def to_bgr(image_data: np.ndarray) -> np.ndarray:\n", + " \"\"\"\n", + " Convert image_data from RGB to BGR.\n", + " \"\"\"\n", + " return cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)" + ] + }, + { + "cell_type": "markdown", + "id": "6a2ec41b", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Data Conversion Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8ae28f4", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "test_array = np.random.randint(0, 255, (100, 100, 3))\n", + "normalized_array = normalize_minmax(test_array)\n", + "\n", + "assert normalized_array.min() == 0\n", + "assert normalized_array.max() == 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2922a67", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "bgr_array = np.ones((100, 100, 3), dtype=np.uint8)\n", + "bgr_array[:, :, 0] = 0\n", + "bgr_array[:, :, 1] = 1\n", + "bgr_array[:, :, 2] = 2\n", + "rgb_array = to_rgb(bgr_array)\n", + "\n", + "assert np.all(bgr_array[:, :, 0] == rgb_array[:, :, 2])\n", + "\n", + "bgr_array_converted = to_bgr(rgb_array)\n", + "assert np.all(bgr_array_converted == bgr_array)" + ] + }, + { + "cell_type": "markdown", + "id": "8e27e37e", + "metadata": {}, + "source": [ + "## Videos" + ] + }, + { + "cell_type": "markdown", + "id": "b134d512", + "metadata": {}, + "source": [ + "### Video Player\n", + "\n", + "A custom video player to fulfill FPS requirements. You can set target FPS and output size, flip the video horizontally or skip first N frames." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd5a3145", + "metadata": { + "pycharm": { + "name": "#%% \n" + } + }, + "outputs": [], + "source": [ + "class VideoPlayer:\n", + " \"\"\"\n", + " Custom video player to fulfill FPS requirements. You can set target FPS and output size,\n", + " flip the video horizontally or skip first N frames.\n", + "\n", + " :param source: Video source. It could be either camera device or video file.\n", + " :param size: Output frame size.\n", + " :param flip: Flip source horizontally.\n", + " :param fps: Target FPS.\n", + " :param skip_first_frames: Skip first N frames.\n", + " \"\"\"\n", + "\n", + " def __init__(self, source, size=None, flip=False, fps=None, skip_first_frames=0):\n", + " self.__cap = cv2.VideoCapture(source)\n", + " if not self.__cap.isOpened():\n", + " raise RuntimeError(\n", + " f\"Cannot open {'camera' if isinstance(source, int) else ''} {source}\"\n", + " )\n", + " # Skip first N frames.\n", + " self.__cap.set(cv2.CAP_PROP_POS_FRAMES, skip_first_frames)\n", + " # fps of input file\n", + " self.__input_fps = self.__cap.get(cv2.CAP_PROP_FPS)\n", + " if self.__input_fps <= 0:\n", + " self.__input_fps = 60\n", + " # target fps given by user\n", + " self.__output_fps = fps if fps is not None else self.__input_fps\n", + " self.__flip = flip\n", + " self.__size = None\n", + " self.__interpolation = None\n", + " if size is not None:\n", + " self.__size = size\n", + " # AREA better for shrinking, LINEAR better for enlarging\n", + " self.__interpolation = (\n", + " cv2.INTER_AREA\n", + " if size[0] < self.__cap.get(cv2.CAP_PROP_FRAME_WIDTH)\n", + " else cv2.INTER_LINEAR\n", + " )\n", + " # first frame\n", + " _, self.__frame = self.__cap.read()\n", + " self.__lock = threading.Lock()\n", + " self.__thread = None\n", + " self.__stop = False\n", + "\n", + " \"\"\"\n", + " Start playing.\n", + " \"\"\"\n", + "\n", + " def start(self):\n", + " self.__stop = False\n", + " self.__thread = threading.Thread(target=self.__run, daemon=True)\n", + " self.__thread.start()\n", + "\n", + " \"\"\"\n", + " Stop playing and release resources.\n", + " \"\"\"\n", + "\n", + " def stop(self):\n", + " self.__stop = True\n", + " if self.__thread is not None:\n", + " self.__thread.join()\n", + " self.__cap.release()\n", + "\n", + " def __run(self):\n", + " prev_time = 0\n", + " while not self.__stop:\n", + " t1 = time.time()\n", + " ret, frame = self.__cap.read()\n", + " if not ret:\n", + " break\n", + "\n", + " # Fulfill target fps.\n", + " if 1 / self.__output_fps < time.time() - prev_time:\n", + " prev_time = time.time()\n", + " # Replace by current frame.\n", + " with self.__lock:\n", + " self.__frame = frame\n", + "\n", + " t2 = time.time()\n", + " # time to wait [s] to fulfill input fps\n", + " wait_time = 1 / self.__input_fps - (t2 - t1)\n", + " # Wait until.\n", + " time.sleep(max(0, wait_time))\n", + "\n", + " self.__frame = None\n", + "\n", + " \"\"\"\n", + " Get current frame.\n", + " \"\"\"\n", + "\n", + " def next(self):\n", + " with self.__lock:\n", + " if self.__frame is None:\n", + " return None\n", + " # Need to copy frame, because it can be cached and reused if fps is low.\n", + " frame = self.__frame.copy()\n", + " if self.__size is not None:\n", + " frame = cv2.resize(frame, self.__size, interpolation=self.__interpolation)\n", + " if self.__flip:\n", + " frame = cv2.flip(frame, 1)\n", + " return frame" + ] + }, + { + "cell_type": "markdown", + "id": "8ab7b29e", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Video Player" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3b1fc3c", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "video = \"../201-vision-monodepth/data/Coco Walking in Berkeley.mp4\"\n", + "\n", + "player = VideoPlayer(video, fps=15, skip_first_frames=10)\n", + "player.start()\n", + "for i in range(50):\n", + " frame = player.next()\n", + " _, encoded_img = cv2.imencode(\".jpg\", frame, params=[cv2.IMWRITE_JPEG_QUALITY, 90])\n", + " img = Image(data=encoded_img)\n", + " clear_output(wait=True)\n", + " display(img)\n", + "\n", + "player.stop()\n", + "print(\"Finished\")" + ] + }, + { + "cell_type": "markdown", + "id": "b9c69891", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "id": "67182f4f", + "metadata": {}, + "source": [ + "### Segmentation\n", + "\n", + "Define a `SegmentationMap NamedTuple` that keeps the labels and colormap for a segmentation project/dataset. Create `CityScapesSegmentation` and `BinarySegmentation SegmentationMaps`. Create a function to convert a segmentation map to an `RGB` image with a `colormap`, and to show the segmentation result as an overlay over the original image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8c64d62", + "metadata": {}, + "outputs": [], + "source": [ + "class Label(NamedTuple):\n", + " index: int\n", + " color: Tuple\n", + " name: Optional[str] = None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "693bd276", + "metadata": {}, + "outputs": [], + "source": [ + "class SegmentationMap(NamedTuple):\n", + " labels: List\n", + "\n", + " def get_colormap(self):\n", + " return np.array([label.color for label in self.labels])\n", + "\n", + " def get_labels(self):\n", + " labelnames = [label.name for label in self.labels]\n", + " if any(labelnames):\n", + " return labelnames\n", + " else:\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd88c7ae", + "metadata": {}, + "outputs": [], + "source": [ + "cityscape_labels = [\n", + " Label(index=0, color=(128, 64, 128), name=\"road\"),\n", + " Label(index=1, color=(244, 35, 232), name=\"sidewalk\"),\n", + " Label(index=2, color=(70, 70, 70), name=\"building\"),\n", + " Label(index=3, color=(102, 102, 156), name=\"wall\"),\n", + " Label(index=4, color=(190, 153, 153), name=\"fence\"),\n", + " Label(index=5, color=(153, 153, 153), name=\"pole\"),\n", + " Label(index=6, color=(250, 170, 30), name=\"traffic light\"),\n", + " Label(index=7, color=(220, 220, 0), name=\"traffic sign\"),\n", + " Label(index=8, color=(107, 142, 35), name=\"vegetation\"),\n", + " Label(index=9, color=(152, 251, 152), name=\"terrain\"),\n", + " Label(index=10, color=(70, 130, 180), name=\"sky\"),\n", + " Label(index=11, color=(220, 20, 60), name=\"person\"),\n", + " Label(index=12, color=(255, 0, 0), name=\"rider\"),\n", + " Label(index=13, color=(0, 0, 142), name=\"car\"),\n", + " Label(index=14, color=(0, 0, 70), name=\"truck\"),\n", + " Label(index=15, color=(0, 60, 100), name=\"bus\"),\n", + " Label(index=16, color=(0, 80, 100), name=\"train\"),\n", + " Label(index=17, color=(0, 0, 230), name=\"motorcycle\"),\n", + " Label(index=18, color=(119, 11, 32), name=\"bicycle\"),\n", + " Label(index=19, color=(255, 255, 255), name=\"background\"),\n", + "]\n", + "\n", + "CityScapesSegmentation = SegmentationMap(cityscape_labels)\n", + "\n", + "binary_labels = [\n", + " Label(index=0, color=(255, 255, 255), name=\"background\"),\n", + " Label(index=1, color=(0, 0, 0), name=\"foreground\"),\n", + "]\n", + "\n", + "BinarySegmentation = SegmentationMap(binary_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0fa0b5dc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def segmentation_map_to_image(\n", + " result: np.ndarray, colormap: np.ndarray, remove_holes: bool = False\n", + ") -> np.ndarray:\n", + " \"\"\"\n", + " Convert network result of floating point numbers to an RGB image with\n", + " integer values from 0-255 by applying a colormap.\n", + "\n", + " :param result: A single network result after converting to pixel values in H,W or 1,H,W shape.\n", + " :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class.\n", + " :param remove_holes: If set to True, remove holes in the segmentation result.\n", + " :return: An RGB image where each pixel is an int8 value according to colormap.\n", + " \"\"\"\n", + " if len(result.shape) != 2 and result.shape[0] != 1:\n", + " raise ValueError(\n", + " f\"Expected result with shape (H,W) or (1,H,W), got result with shape {result.shape}\"\n", + " )\n", + "\n", + " if len(np.unique(result)) > colormap.shape[0]:\n", + " raise ValueError(\n", + " f\"Expected max {colormap[0]} classes in result, got {len(np.unique(result))} \"\n", + " \"different output values. Make sure to convert the network output to \"\n", + " \"pixel values before calling this function.\"\n", + " )\n", + " elif result.shape[0] == 1:\n", + " result = result.squeeze(0)\n", + "\n", + " result = result.astype(np.uint8)\n", + "\n", + " contour_mode = cv2.RETR_EXTERNAL if remove_holes else cv2.RETR_TREE\n", + " mask = np.zeros((result.shape[0], result.shape[1], 3), dtype=np.uint8)\n", + " for label_index, color in enumerate(colormap):\n", + " label_index_map = result == label_index\n", + " label_index_map = label_index_map.astype(np.uint8) * 255\n", + " contours, hierarchies = cv2.findContours(\n", + " label_index_map, contour_mode, cv2.CHAIN_APPROX_SIMPLE\n", + " )\n", + " cv2.drawContours(\n", + " mask,\n", + " contours,\n", + " contourIdx=-1,\n", + " color=color.tolist(),\n", + " thickness=cv2.FILLED,\n", + " )\n", + "\n", + " return mask\n", + "\n", + "\n", + "def segmentation_map_to_overlay(image, result, alpha, colormap, remove_holes=False) -> np.ndarray:\n", + " \"\"\"\n", + " Returns a new image where a segmentation mask (created with colormap) is overlayed on\n", + " the source image.\n", + "\n", + " :param image: Source image.\n", + " :param result: A single network result after converting to pixel values in H,W or 1,H,W shape.\n", + " :param alpha: Alpha transparency value for the overlay image.\n", + " :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class.\n", + " :param remove_holes: If set to True, remove holes in the segmentation result.\n", + " :return: An RGP image with segmentation mask overlayed on the source image.\n", + " \"\"\"\n", + " if len(image.shape) == 2:\n", + " image = np.repeat(np.expand_dims(image, -1), 3, 2)\n", + " mask = segmentation_map_to_image(result, colormap, remove_holes)\n", + " image_height, image_width = image.shape[:2]\n", + " mask = cv2.resize(src=mask, dsize=(image_width, image_height))\n", + " return cv2.addWeighted(mask, alpha, image, 1 - alpha, 0)" + ] + }, + { + "cell_type": "markdown", + "id": "72ab2c0c", + "metadata": {}, + "source": [ + "### Network Results\n", + "\n", + "Show network result image, optionally together with the source image and a legend with labels." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d162edd1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def viz_result_image(\n", + " result_image: np.ndarray,\n", + " source_image: np.ndarray = None,\n", + " source_title: str = None,\n", + " result_title: str = None,\n", + " labels: List[Label] = None,\n", + " resize: bool = False,\n", + " bgr_to_rgb: bool = False,\n", + " hide_axes: bool = False,\n", + ") -> matplotlib.figure.Figure:\n", + " \"\"\"\n", + " Show result image, optionally together with source images, and a legend with labels.\n", + "\n", + " :param result_image: Numpy array of RGB result image.\n", + " :param source_image: Numpy array of source image. If provided, this image will be shown\n", + " next to the result image. The 'source_image' is expected to be in RGB format.\n", + " Set `bgr_to_rgb` to True if `source_image` is in BGR format.\n", + " :param source_title: Title to display for the source image.\n", + " :param result_title: Title to display for the result image.\n", + " :param labels: List of labels. If provided, a legend will be shown with the given labels.\n", + " :param resize: If set to True, resize the result image to the same shape as the source image.\n", + " :param bgr_to_rgb: If set to True, convert the source image from BGR to RGB. Use this option if\n", + " `source_image` is a BGR image.\n", + " :param hide_axes: If set to True, do not show matplotlib axes.\n", + " :return: Matplotlib figure with the result image.\n", + " \"\"\"\n", + " if bgr_to_rgb:\n", + " source_image = to_rgb(source_image)\n", + " if resize:\n", + " result_image = cv2.resize(result_image, (source_image.shape[1], source_image.shape[0]))\n", + "\n", + " num_images = 1 if source_image is None else 2\n", + "\n", + " fig, ax = plt.subplots(1, num_images, figsize=(16, 8), squeeze=False)\n", + " if source_image is not None:\n", + " ax[0, 0].imshow(source_image)\n", + " ax[0, 0].set_title(source_title)\n", + "\n", + " ax[0, num_images - 1].imshow(result_image)\n", + " ax[0, num_images - 1].set_title(result_title)\n", + "\n", + " if hide_axes:\n", + " for a in ax.ravel():\n", + " a.axis(\"off\")\n", + " if labels:\n", + " colors = labels.get_colormap()\n", + " lines = [\n", + " Line2D(\n", + " [0],\n", + " [0],\n", + " color=[item / 255 for item in c.tolist()],\n", + " linewidth=3,\n", + " linestyle=\"-\",\n", + " )\n", + " for c in colors\n", + " ]\n", + " plt.legend(\n", + " lines,\n", + " labels.get_labels(),\n", + " bbox_to_anchor=(1, 1),\n", + " loc=\"upper left\",\n", + " prop={\"size\": 12},\n", + " )\n", + " plt.close(fig)\n", + " return fig" + ] + }, + { + "cell_type": "markdown", + "id": "a6f109c8-1b31-44ce-9c8e-6e52dd489994", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Visualization Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d300c70", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "testimage = np.zeros((100, 100, 3), dtype=np.uint8)\n", + "testimage[30:80, 30:80, :] = [0, 255, 0]\n", + "testimage[0:10, 0:10, :] = 100\n", + "testimage[40:60, 40:60, :] = 128\n", + "testimage[testimage == 0] = 128\n", + "\n", + "\n", + "testmask1 = np.zeros((testimage.shape[:2]))\n", + "testmask1[30:80, 30:80] = 1\n", + "testmask1[40:50, 40:50] = 0\n", + "testmask1[0:15, 0:10] = 2\n", + "\n", + "result_image_overlay = segmentation_map_to_overlay(\n", + " image=testimage,\n", + " result=testmask1,\n", + " alpha=0.6,\n", + " colormap=np.array([[0, 0, 0], [255, 0, 0], [255, 255, 0]]),\n", + ")\n", + "result_image = segmentation_map_to_image(testmask1, CityScapesSegmentation.get_colormap())\n", + "result_image_no_holes = segmentation_map_to_image(\n", + " testmask1, CityScapesSegmentation.get_colormap(), remove_holes=True\n", + ")\n", + "resized_result_image = cv2.resize(result_image, (50, 50))\n", + "overlay_result_image = segmentation_map_to_overlay(\n", + " testimage, testmask1, 0.6, CityScapesSegmentation.get_colormap(), remove_holes=False\n", + ")\n", + "\n", + "fig1 = viz_result_image(result_image, testimage)\n", + "fig2 = viz_result_image(result_image_no_holes, testimage, labels=CityScapesSegmentation)\n", + "fig3 = viz_result_image(\n", + " resized_result_image,\n", + " testimage,\n", + " source_title=\"Source Image\",\n", + " result_title=\"Resized Result Image\",\n", + " resize=True,\n", + ")\n", + "fig4 = viz_result_image(\n", + " overlay_result_image,\n", + " labels=CityScapesSegmentation,\n", + " result_title=\"Image with Result Overlay\",\n", + ")\n", + "\n", + "display(fig1, fig2, fig3, fig4)" + ] + }, + { + "cell_type": "markdown", + "id": "97885ed0-8dea-4511-8558-bf146f5ae9d9", + "metadata": {}, + "source": [ + "### Live Inference" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3cf6f55-3d43-467b-94ed-318e345a4d1c", + "metadata": {}, + "outputs": [], + "source": [ + "def showarray(frame: np.ndarray, display_handle=None):\n", + " \"\"\"\n", + " Display `frame` array. Replace information at `display_handle` with `frame`\n", + " encoded as jpeg image. The `frame` array is expected to have data in BGR order.\n", + "\n", + " Create a `display_handle` with: `display_handle = display(display_id=True)`\n", + " \"\"\"\n", + " _, frame = cv2.imencode(ext=\".jpeg\", img=frame)\n", + " if display_handle is None:\n", + " display_handle = display(Image(data=frame.tobytes()), display_id=True)\n", + " else:\n", + " display_handle.update(Image(data=frame.tobytes()))\n", + " return display_handle\n", + "\n", + "\n", + "def show_live_inference(\n", + " ie, image_paths: List, model: model.Model, device: str, reader: Optional[Callable] = None\n", + "):\n", + " \"\"\"\n", + " Do inference of images listed in `image_paths` on `model` on the given `device` and show\n", + " the results in real time in a Jupyter Notebook.\n", + "\n", + " :param image_paths: List of image filenames to load.\n", + " :param model: Model instance for inference.\n", + " :param device: Name of device to perform inference on. For example: \"CPU\".\n", + " :param reader: Image reader. Should return a numpy array with image data.\n", + " If set to None, `cv2.imread` will be used, with the `cv2.IMREAD_UNCHANGED` flag.\n", + " \"\"\"\n", + " display_handle = None\n", + " next_frame_id = 0\n", + " next_frame_id_to_show = 0\n", + "\n", + " input_layer = next(iter(model.net.input_info))\n", + "\n", + " # Create asynchronous pipeline and print time it takes to load the model.\n", + " load_start_time = time.perf_counter()\n", + " pipeline = AsyncPipeline(\n", + " ie=ie, model=model, plugin_config={}, device=device, max_num_requests=0\n", + " )\n", + " load_end_time = time.perf_counter()\n", + "\n", + " # Perform asynchronous inference.\n", + " start_time = time.perf_counter()\n", + "\n", + " while next_frame_id < len(image_paths) - 1:\n", + " results = pipeline.get_result(next_frame_id_to_show)\n", + "\n", + " if results:\n", + " # Show next result from async pipeline.\n", + " result, meta = results\n", + " display_handle = showarray(result, display_handle)\n", + " next_frame_id_to_show += 1\n", + " if pipeline.is_ready():\n", + " # Submit a new image to async pipeline.\n", + " image_path = image_paths[next_frame_id]\n", + " if reader is None:\n", + " image = cv2.imread(filename=str(image_path), flags=cv2.IMREAD_UNCHANGED)\n", + " else:\n", + " image = reader(str(image_path))\n", + " pipeline.submit_data(\n", + " inputs={input_layer: image}, id=next_frame_id, meta={\"frame\": image}\n", + " )\n", + " del image\n", + " next_frame_id += 1\n", + " else:\n", + " # If the pipeline is not ready yet and there are no results: wait.\n", + " pipeline.await_any()\n", + "\n", + " pipeline.await_all()\n", + "\n", + " # Show all frames that are in the pipeline after all images have been submitted.\n", + " while pipeline.has_completed_request():\n", + " results = pipeline.get_result(next_frame_id_to_show)\n", + " if results:\n", + " result, meta = results\n", + " display_handle = showarray(result, display_handle)\n", + " next_frame_id_to_show += 1\n", + "\n", + " end_time = time.perf_counter()\n", + " duration = end_time - start_time\n", + " fps = len(image_paths) / duration\n", + " print(f\"Loaded model to {device} in {load_end_time-load_start_time:.2f} seconds.\")\n", + " print(f\"Total time for {next_frame_id} frames: {duration:.2f} seconds, fps:{fps:.2f}\")\n", + "\n", + " del pipeline.exec_net\n", + " del pipeline" + ] + }, + { + "cell_type": "markdown", + "id": "45df4809-567b-4d3b-b947-d4a0ed981ce9", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "#### Test Live Inference" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e6be35b-de7b-47b7-8cd1-f6ef96e2d0cb", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "# Test binary segmentation\n", + "from models.custom_segmentation import SegmentationModel\n", + "\n", + "image_paths = sorted(list(Path(\"../111-detection-quantization/data\").glob(\"*.jpg\")))\n", + "\n", + "ie = IECore()\n", + "segmentation_model = SegmentationModel(\n", + " ie,\n", + " Path(\"model/segmentation.xml\"),\n", + " sigmoid=False,\n", + " colormap=np.array([[0, 0, 0], [0, 0, 255]]),\n", + " rgb=True,\n", + " rotate_and_flip=False,\n", + ")\n", + "\n", + "show_live_inference(\n", + " ie=ie,\n", + " image_paths=image_paths,\n", + " model=segmentation_model,\n", + " device=\"CPU\",\n", + " reader=lambda x: cv2.cvtColor(cv2.imread(x), cv2.COLOR_BGR2RGB),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c42b9127-74b5-4172-8104-5aacf6a22b9c", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "# Test multiclass segmentation with different input shape.\n", + "# This requires running the 102 notebook first, to generate the Fastseg model.\n", + "\n", + "fastseg_path = Path(\"../102-pytorch-onnx-to-openvino/model/fastseg1024.xml\")\n", + "image_path = \"../102-pytorch-onnx-to-openvino/data/street.jpg\"\n", + "\n", + "if fastseg_path.exists():\n", + " image_paths = [\n", + " image_path,\n", + " ] * 5\n", + "\n", + " ie = IECore()\n", + " CityScapesSegmentation = SegmentationMap(cityscape_labels)\n", + " segmentation_model = SegmentationModel(\n", + " ie,\n", + " fastseg_path,\n", + " sigmoid=False,\n", + " argmax=True,\n", + " colormap=CityScapesSegmentation.get_colormap(),\n", + " rgb=True,\n", + " )\n", + " show_live_inference(ie=ie, image_paths=image_paths, model=segmentation_model, device=\"CPU\")" + ] + }, + { + "cell_type": "markdown", + "id": "13eba0a6-1494-478c-ba01-e1ed6cdee608", + "metadata": { + "tags": [] + }, + "source": [ + "## OpenVINO Tools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0214f54b-0873-4200-8c3a-73760594cdf4", + "metadata": {}, + "outputs": [], + "source": [ + "def benchmark_model(\n", + " model_path: PathLike,\n", + " device: str = \"CPU\",\n", + " seconds: int = 60,\n", + " api: str = \"async\",\n", + " batch: int = 1,\n", + " cache_dir: PathLike = \"model_cache\",\n", + "):\n", + " \"\"\"\n", + " Benchmark model specified in `model_path` with `benchmark_app`. Returns the output of `benchmark_app`\n", + " without logging info, and information about the device.\n", + "\n", + " :param model_path: The path to an xml file of the OpenVINO IR model, or ONNX model.\n", + " :param device: A device to benchmark on. For example, \"CPU\" or \"MULTI:CPU,GPU\".\n", + " :param seconds: A number of seconds to run benchmark_app.\n", + " :param api: API. Possible options: sync or async.\n", + " :param batch: Batch size.\n", + " :param cache_dir: A directory that contains model/kernel cache files.\n", + " \"\"\"\n", + " ie = IECore()\n", + " model_path = Path(model_path)\n", + " if (\"GPU\" in device) and (\"GPU\" not in ie.available_devices):\n", + " raise ValueError(\n", + " f\"A GPU device is not available. Available devices are: {ie.available_devices}\"\n", + " )\n", + " else:\n", + " benchmark_command = f\"benchmark_app -m {model_path} -d {device} -t {seconds} -api {api} -b {batch} -cdir {cache_dir}\"\n", + " display(\n", + " Markdown(\n", + " f\"**Benchmark {model_path.name} with {device} for {seconds} seconds with {api} inference**\"\n", + " )\n", + " )\n", + " display(Markdown(f\"Benchmark command: `{benchmark_command}`\"))\n", + "\n", + " benchmark_output = get_ipython().run_line_magic(\"sx\", \"$benchmark_command\")\n", + " benchmark_result = [\n", + " line\n", + " for line in benchmark_output\n", + " if not (line.startswith(r\"[\") or line.startswith(\" \") or line == \"\")\n", + " ]\n", + " print(\"\\n\".join(benchmark_result))\n", + " print()\n", + " if \"MULTI\" in device:\n", + " devices = device.replace(\"MULTI:\", \"\").split(\",\")\n", + " for single_device in devices:\n", + " device_name = ie.get_metric(\n", + " device_name=single_device, metric_name=\"FULL_DEVICE_NAME\"\n", + " )\n", + " print(f\"{single_device} device: {device_name}\")\n", + " else:\n", + " print(f\"Device: {ie.get_metric(device_name=device, metric_name='FULL_DEVICE_NAME')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb29655c-d1d8-4f73-b56d-2389ef1cc237", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test OpenVINO Tools\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "093969fd-149d-4f6c-8e13-6ed6705170ed", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "ie = IECore()\n", + "model_url = \"https://github.com/openvinotoolkit/openvino_notebooks/raw/main/notebooks/002-openvino-api/model/segmentation.xml\"\n", + "model_path = download_ir_model(model_url, \"model\")\n", + "device = \"MULTI:CPU,GPU\" if \"GPU\" in ie.available_devices else \"CPU\"\n", + "display(Markdown(device))\n", + "benchmark_model(model_path=model_path, device=device, seconds=5)" + ] + }, + { + "cell_type": "markdown", + "id": "46431fa9", + "metadata": {}, + "source": [ + "## Checks and Alerts\n", + "\n", + "Create an alert class to show stylized info/error/warning messages and a `check_device` function that checks whether a given device is available." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f5ccdef", + "metadata": {}, + "outputs": [], + "source": [ + "class NotebookAlert(Exception):\n", + " def __init__(self, message: str, alert_class: str):\n", + " \"\"\"\n", + " Show an alert box with the given message.\n", + "\n", + " :param message: The message to display.\n", + " :param alert_class: The class for styling the message. Options: info, warning, success, danger.\n", + " \"\"\"\n", + " self.message = message\n", + " self.alert_class = alert_class\n", + " self.show_message()\n", + "\n", + " def show_message(self):\n", + " display(HTML(f\"\"\"
{self.message}\"\"\"))\n", + "\n", + "\n", + "class DeviceNotFoundAlert(NotebookAlert):\n", + " def __init__(self, device: str):\n", + " \"\"\"\n", + " Show a warning message about an unavailable device. This class does not check whether or\n", + " not the device is available, use `check_device` to check this. The `check_device` function\n", + " also shows the warning if the device is not found.\n", + "\n", + " :param device: The unavailable device.\n", + " :return: A formatted alert box with the message that `device` is not available, and a list\n", + " of devices that are available.\n", + " \"\"\"\n", + " ie = IECore()\n", + " supported_devices = ie.available_devices\n", + " self.message = (\n", + " f\"Running this cell requires a {device} device, \"\n", + " \"which is not available on this system. \"\n", + " )\n", + " self.alert_class = \"warning\"\n", + " if len(supported_devices) == 1:\n", + " self.message += f\"The following device is available: {ie.available_devices[0]}\"\n", + " else:\n", + " self.message += (\n", + " \"The following devices are available: \" f\"{', '.join(ie.available_devices)}\"\n", + " )\n", + " super().__init__(self.message, self.alert_class)\n", + "\n", + "\n", + "def check_device(device: str) -> bool:\n", + " \"\"\"\n", + " Check if the specified device is available on the system.\n", + "\n", + " :param device: Device to check. For example, CPU, GPU.\n", + " :return: True if the device is available, False if not. If the device is not available,\n", + " a `DeviceNotFoundAlert` message will be shown.\n", + " \"\"\"\n", + " ie = IECore()\n", + " if device not in ie.available_devices:\n", + " DeviceNotFoundAlert(device)\n", + " return False\n", + " else:\n", + " return True\n", + "\n", + "\n", + "def check_openvino_version(version: str) -> bool:\n", + " \"\"\"\n", + " Check if the specified OpenVINO version is installed.\n", + "\n", + " :param version: The OpenVINO version to check. Example: 2021.4.\n", + " :return: True if the version is installed, False if not. If the version is not installed,\n", + " an alert message will be shown.\n", + " \"\"\"\n", + " installed_version = openvino.inference_engine.get_version()\n", + " if version not in installed_version:\n", + " NotebookAlert(\n", + " f\"This notebook requires OpenVINO {version}. \"\n", + " f\"The version on your system is: {installed_version}.
\"\n", + " \"Run pip install --upgrade -r requirements.txt \"\n", + " \"in the 'openvino_env' environment to install this version. \"\n", + " \"See the \"\n", + " \"OpenVINO Notebooks README for detailed instructions\",\n", + " alert_class=\"danger\",\n", + " )\n", + " return False\n", + " else:\n", + " return True" + ] + }, + { + "cell_type": "markdown", + "id": "a19e1d08", + "metadata": { + "tags": [ + "hide" + ] + }, + "source": [ + "### Test Alerts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7983c8f", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "NotebookAlert(message=\"Hello, world!\", alert_class=\"info\")\n", + "DeviceNotFoundAlert(\"GPU\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6bda8ef3", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "assert check_device(\"CPU\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "944820e1", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "if check_device(\"HELLOWORLD\"):\n", + " print(\"Hello World device found.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41c370ef", + "metadata": { + "tags": [ + "hide" + ] + }, + "outputs": [], + "source": [ + "check_openvino_version(\"2022.1\");" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "interpreter": { + "hash": "ae617ccb002f72b3ab6d0069d721eac67ac2a969e83c083c4321cfcab0437cd1" + }, + "kernelspec": { + "display_name": "Python 3", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/session_4/utils/notebook_utils.py b/session_4/utils/notebook_utils.py new file mode 100644 index 0000000..0745459 --- /dev/null +++ b/session_4/utils/notebook_utils.py @@ -0,0 +1,762 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[ ]: + + +import os +import shutil +import socket +import threading +import time +import urllib +import urllib.parse +import urllib.request +from os import PathLike +from pathlib import Path +from typing import Callable, List, NamedTuple, Optional, Tuple + +import cv2 +import matplotlib +import matplotlib.pyplot as plt +import numpy as np +import openvino.inference_engine +from async_pipeline import AsyncPipeline +from IPython.display import HTML, Image, Markdown, clear_output, display +from matplotlib.lines import Line2D +from models import model +from openvino.inference_engine import IECore +from tqdm.notebook import tqdm_notebook + + +# ## Files +# +# Load an image, download a file, download an IR model, and create a progress bar to show download progress. + +# In[ ]: + + +def load_image(path: str) -> np.ndarray: + """ + Loads an image from `path` and returns it as BGR numpy array. `path` + should point to an image file, either a local filename or a url. The image is + not stored to the filesystem. Use the `download_file` function to download and + store an image. + + :param path: Local path name or URL to image. + :return: image as BGR numpy array + """ + if path.startswith("http"): + # Set User-Agent to Mozilla because some websites block + # requests with User-Agent Python + request = urllib.request.Request(path, headers={"User-Agent": "Mozilla/5.0"}) + response = urllib.request.urlopen(request) + array = np.asarray(bytearray(response.read()), dtype="uint8") + image = cv2.imdecode(array, -1) # Loads the image as BGR + else: + image = cv2.imread(path) + return image + + +class DownloadProgressBar(tqdm_notebook): + """ + TQDM Progress bar for downloading files with urllib.request.urlretrieve + """ + + def update_to(self, block_num: int, block_size: int, total_size: int): + downloaded = block_num * block_size + if downloaded <= total_size: + self.update(downloaded - self.n) + + +def download_file( + url: PathLike, + filename: PathLike = None, + directory: PathLike = None, + show_progress: bool = True, + silent: bool = False, + timeout: int = 10, +) -> str: + """ + Download a file from a url and save it to the local filesystem. The file is saved to the + current directory by default, or to `directory` if specified. If a filename is not given, + the filename of the URL will be used. + + :param url: URL that points to the file to download + :param filename: Name of the local file to save. Should point to the name of the file only, + not the full path. If None the filename from the url will be used + :param directory: Directory to save the file to. Will be created if it doesn't exist + If None the file will be saved to the current working directory + :param show_progress: If True, show an TQDM ProgressBar + :param silent: If True, do not print a message if the file already exists + :param timeout: Number of seconds before cancelling the connection attempt + :return: path to downloaded file + """ + try: + opener = urllib.request.build_opener() + opener.addheaders = [("User-agent", "Mozilla/5.0")] + urllib.request.install_opener(opener) + urlobject = urllib.request.urlopen(url, timeout=timeout) + if filename is None: + filename = urlobject.info().get_filename() or Path(urllib.parse.urlparse(url).path).name + except urllib.error.HTTPError as e: + raise Exception(f"File downloading failed with error: {e.code} {e.msg}") from None + except urllib.error.URLError as error: + if isinstance(error.reason, socket.timeout): + raise Exception( + "Connection timed out. If you access the internet through a proxy server, please " + "make sure the proxy is set in the shell from where you launched Jupyter. If your " + "internet connection is slow, you can call `download_file(url, timeout=30)` to " + "wait for 30 seconds before raising this error." + ) from None + else: + raise + + filename = Path(filename) + if len(filename.parts) > 1: + raise ValueError( + "`filename` should refer to the name of the file, excluding the directory. " + "Use the `directory` parameter to specify a target directory for the downloaded file." + ) + + # create the directory if it does not exist, and add the directory to the filename + if directory is not None: + directory = Path(directory) + directory.mkdir(parents=True, exist_ok=True) + filename = directory / Path(filename) + + # download the file if it does not exist, or if it exists with an incorrect file size + urlobject_size = int(urlobject.info().get("Content-Length", 0)) + if not filename.exists() or (os.stat(filename).st_size != urlobject_size): + progress_callback = DownloadProgressBar( + total=urlobject_size, + unit="B", + unit_scale=True, + unit_divisor=1024, + desc=str(filename), + disable=not show_progress, + ) + urllib.request.urlretrieve(url, filename, reporthook=progress_callback.update_to) + if os.stat(filename).st_size >= urlobject_size: + progress_callback.update(urlobject_size - progress_callback.n) + progress_callback.refresh() + else: + if not silent: + print(f"'{filename}' already exists.") + return filename.resolve() + + +def download_ir_model(model_xml_url: str, destination_folder: PathLike = None) -> PathLike: + """ + Download IR model from `model_xml_url`. Downloads model xml and bin file; the weights file is + assumed to exist at the same location and name as model_xml_url with a ".bin" extension. + + :param model_xml_url: URL to model xml file to download + :param destination_folder: Directory where downloaded model xml and bin are saved. If None, model + files are saved to the current directory + :return: path to downloaded xml model file + """ + model_bin_url = model_xml_url[:-4] + ".bin" + model_xml_path = download_file(model_xml_url, directory=destination_folder, show_progress=False) + download_file(model_bin_url, directory=destination_folder) + return model_xml_path + + +# ## Images + +# ### Convert Pixel Data +# +# Normalize image pixel values between 0 and 1, and convert images to RGB and BGR. + +# In[ ]: + + +def normalize_minmax(data): + """ + Normalizes the values in `data` between 0 and 1 + """ + if data.max() == data.min(): + raise ValueError( + "Normalization is not possible because all elements of" + f"`data` have the same value: {data.max()}." + ) + return (data - data.min()) / (data.max() - data.min()) + + +def to_rgb(image_data: np.ndarray) -> np.ndarray: + """ + Convert image_data from BGR to RGB + """ + return cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB) + + +def to_bgr(image_data: np.ndarray) -> np.ndarray: + """ + Convert image_data from RGB to BGR + """ + return cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR) + + +# ## Videos + +# ### Video Player +# +# Custom video player to fulfill FPS requirements. You can set target FPS and output size, flip the video horizontally or skip first N frames. + +# In[ ]: + + +class VideoPlayer: + """ + Custom video player to fulfill FPS requirements. You can set target FPS and output size, + flip the video horizontally or skip first N frames. + + :param source: Video source. It could be either camera device or video file. + :param size: Output frame size. + :param flip: Flip source horizontally. + :param fps: Target FPS. + :param skip_first_frames: Skip first N frames. + """ + + def __init__(self, source, size=None, flip=False, fps=None, skip_first_frames=0): + self.__cap = cv2.VideoCapture(source) + if not self.__cap.isOpened(): + raise RuntimeError( + f"Cannot open {'camera' if isinstance(source, int) else ''} {source}" + ) + # skip first N frames + self.__cap.set(cv2.CAP_PROP_POS_FRAMES, skip_first_frames) + # fps of input file + self.__input_fps = self.__cap.get(cv2.CAP_PROP_FPS) + if self.__input_fps <= 0: + self.__input_fps = 60 + # target fps given by user + self.__output_fps = fps if fps is not None else self.__input_fps + self.__flip = flip + self.__size = None + self.__interpolation = None + if size is not None: + self.__size = size + # AREA better for shrinking, LINEAR better for enlarging + self.__interpolation = ( + cv2.INTER_AREA + if size[0] < self.__cap.get(cv2.CAP_PROP_FRAME_WIDTH) + else cv2.INTER_LINEAR + ) + # first frame + _, self.__frame = self.__cap.read() + self.__lock = threading.Lock() + self.__thread = None + self.__stop = False + + """ + Start playing. + """ + + def start(self): + self.__stop = False + self.__thread = threading.Thread(target=self.__run, daemon=True) + self.__thread.start() + + """ + Stop playing and release resources. + """ + + def stop(self): + self.__stop = True + if self.__thread is not None: + self.__thread.join() + self.__cap.release() + + def __run(self): + prev_time = 0 + while not self.__stop: + t1 = time.time() + ret, frame = self.__cap.read() + if not ret: + break + + # fulfill target fps + if 1 / self.__output_fps < time.time() - prev_time: + prev_time = time.time() + # replace by current frame + with self.__lock: + self.__frame = frame + + t2 = time.time() + # time to wait [s] to fulfill input fps + wait_time = 1 / self.__input_fps - (t2 - t1) + # wait until + time.sleep(max(0, wait_time)) + + self.__frame = None + + """ + Get current frame. + """ + + def next(self): + with self.__lock: + if self.__frame is None: + return None + # need to copy frame, because can be cached and reused if fps is low + frame = self.__frame.copy() + if self.__size is not None: + frame = cv2.resize(frame, self.__size, interpolation=self.__interpolation) + if self.__flip: + frame = cv2.flip(frame, 1) + return frame + + +# ## Visualization + +# ### Segmentation +# +# Define a SegmentationMap NamedTuple that keeps the labels and colormap for a segmentation project/dataset. Create CityScapesSegmentation and BinarySegmentation SegmentationMaps. Create a function to convert a segmentation map to an RGB image with a colormap, and to show the segmentation result as an overlay over the original image. + +# In[ ]: + + +class Label(NamedTuple): + index: int + color: Tuple + name: Optional[str] = None + + +# In[ ]: + + +class SegmentationMap(NamedTuple): + labels: List + + def get_colormap(self): + return np.array([label.color for label in self.labels]) + + def get_labels(self): + labelnames = [label.name for label in self.labels] + if any(labelnames): + return labelnames + else: + return None + + +# In[ ]: + + +cityscape_labels = [ + Label(index=0, color=(128, 64, 128), name="road"), + Label(index=1, color=(244, 35, 232), name="sidewalk"), + Label(index=2, color=(70, 70, 70), name="building"), + Label(index=3, color=(102, 102, 156), name="wall"), + Label(index=4, color=(190, 153, 153), name="fence"), + Label(index=5, color=(153, 153, 153), name="pole"), + Label(index=6, color=(250, 170, 30), name="traffic light"), + Label(index=7, color=(220, 220, 0), name="traffic sign"), + Label(index=8, color=(107, 142, 35), name="vegetation"), + Label(index=9, color=(152, 251, 152), name="terrain"), + Label(index=10, color=(70, 130, 180), name="sky"), + Label(index=11, color=(220, 20, 60), name="person"), + Label(index=12, color=(255, 0, 0), name="rider"), + Label(index=13, color=(0, 0, 142), name="car"), + Label(index=14, color=(0, 0, 70), name="truck"), + Label(index=15, color=(0, 60, 100), name="bus"), + Label(index=16, color=(0, 80, 100), name="train"), + Label(index=17, color=(0, 0, 230), name="motorcycle"), + Label(index=18, color=(119, 11, 32), name="bicycle"), + Label(index=19, color=(255, 255, 255), name="background"), +] + +CityScapesSegmentation = SegmentationMap(cityscape_labels) + +binary_labels = [ + Label(index=0, color=(255, 255, 255), name="background"), + Label(index=1, color=(0, 0, 0), name="foreground"), +] + +BinarySegmentation = SegmentationMap(binary_labels) + + +# In[ ]: + + +def segmentation_map_to_image( + result: np.ndarray, colormap: np.ndarray, remove_holes: bool = False +) -> np.ndarray: + """ + Convert network result of floating point numbers to an RGB image with + integer values from 0-255 by applying a colormap. + + :param result: A single network result after converting to pixel values in H,W or 1,H,W shape. + :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class. + :param remove_holes: If True, remove holes in the segmentation result. + :return: An RGB image where each pixel is an int8 value according to colormap. + """ + if len(result.shape) != 2 and result.shape[0] != 1: + raise ValueError( + f"Expected result with shape (H,W) or (1,H,W), got result with shape {result.shape}" + ) + + if len(np.unique(result)) > colormap.shape[0]: + raise ValueError( + f"Expected max {colormap[0]} classes in result, got {len(np.unique(result))} " + "different output values. Please make sure to convert the network output to " + "pixel values before calling this function." + ) + elif result.shape[0] == 1: + result = result.squeeze(0) + + result = result.astype(np.uint8) + + contour_mode = cv2.RETR_EXTERNAL if remove_holes else cv2.RETR_TREE + mask = np.zeros((result.shape[0], result.shape[1], 3), dtype=np.uint8) + for label_index, color in enumerate(colormap): + label_index_map = result == label_index + label_index_map = label_index_map.astype(np.uint8) * 255 + contours, hierarchies = cv2.findContours( + label_index_map, contour_mode, cv2.CHAIN_APPROX_SIMPLE + ) + cv2.drawContours( + mask, + contours, + contourIdx=-1, + color=color.tolist(), + thickness=cv2.FILLED, + ) + + return mask + + +def segmentation_map_to_overlay(image, result, alpha, colormap, remove_holes=False) -> np.ndarray: + """ + Returns a new image where a segmentation mask (created with colormap) is overlayed on + the source image. + + :param image: Source image. + :param result: A single network result after converting to pixel values in H,W or 1,H,W shape. + :param alpha: Alpha transparency value for the overlay image. + :param colormap: A numpy array of shape (num_classes, 3) with an RGB value per class. + :param remove_holes: If True, remove holes in the segmentation result. + :return: An RGP image with segmentation mask overlayed on the source image. + """ + if len(image.shape) == 2: + image = np.repeat(np.expand_dims(image, -1), 3, 2) + mask = segmentation_map_to_image(result, colormap, remove_holes) + image_height, image_width = image.shape[:2] + mask = cv2.resize(src=mask, dsize=(image_width, image_height)) + return cv2.addWeighted(mask, alpha, image, 1 - alpha, 0) + + +# ### Network Results +# +# Show network result image, optionally together with the source image and a legend with labels. + +# In[ ]: + + +def viz_result_image( + result_image: np.ndarray, + source_image: np.ndarray = None, + source_title: str = None, + result_title: str = None, + labels: List[Label] = None, + resize: bool = False, + bgr_to_rgb: bool = False, + hide_axes: bool = False, +) -> matplotlib.figure.Figure: + """ + Show result image, optionally together with source images, and a legend with labels. + + :param result_image: Numpy array of RGB result image. + :param source_image: Numpy array of source image. If provided this image will be shown + next to the result image. source_image is expected to be in RGB format. + Set bgr_to_rgb to True if source_image is in BGR format. + :param source_title: Title to display for the source image. + :param result_title: Title to display for the result image. + :param labels: List of labels. If provided, a legend will be shown with the given labels. + :param resize: If true, resize the result image to the same shape as the source image. + :param bgr_to_rgb: If true, convert the source image from BGR to RGB. Use this option if + source_image is a BGR image. + :param hide_axes: If true, do not show matplotlib axes. + :return: Matplotlib figure with result image + """ + if bgr_to_rgb: + source_image = to_rgb(source_image) + if resize: + result_image = cv2.resize(result_image, (source_image.shape[1], source_image.shape[0])) + + num_images = 1 if source_image is None else 2 + + fig, ax = plt.subplots(1, num_images, figsize=(16, 8), squeeze=False) + if source_image is not None: + ax[0, 0].imshow(source_image) + ax[0, 0].set_title(source_title) + + ax[0, num_images - 1].imshow(result_image) + ax[0, num_images - 1].set_title(result_title) + + if hide_axes: + for a in ax.ravel(): + a.axis("off") + if labels: + colors = labels.get_colormap() + lines = [ + Line2D( + [0], + [0], + color=[item / 255 for item in c.tolist()], + linewidth=3, + linestyle="-", + ) + for c in colors + ] + plt.legend( + lines, + labels.get_labels(), + bbox_to_anchor=(1, 1), + loc="upper left", + prop={"size": 12}, + ) + plt.close(fig) + return fig + + +# ### Live Inference + +# In[ ]: + + +def showarray(frame: np.ndarray, display_handle=None): + """ + Display array `frame`. Replace information at `display_handle` with `frame` + encoded as jpeg image. `frame` is expected to have data in BGR order. + + Create a display_handle with: `display_handle = display(display_id=True)` + """ + _, frame = cv2.imencode(ext=".jpeg", img=frame) + if display_handle is None: + display_handle = display(Image(data=frame.tobytes()), display_id=True) + else: + display_handle.update(Image(data=frame.tobytes())) + return display_handle + + +def show_live_inference( + ie, image_paths: List, model: model.Model, device: str, reader: Optional[Callable] = None +): + """ + Do inference of images listed in `image_paths` on `model` on the given `device` and show + the results in real time in a Jupyter Notebook + + :param image_paths: List of image filenames to load + :param model: Model instance for inference + :param device: Name of device to perform inference on. For example: "CPU" + :param reader: Image reader. Should return a numpy array with image data. + If None, cv2.imread will be used, with the cv2.IMREAD_UNCHANGED flag + """ + display_handle = None + next_frame_id = 0 + next_frame_id_to_show = 0 + + input_layer = next(iter(model.net.input_info)) + + # Create asynchronous pipeline and print time it takes to load the model + load_start_time = time.perf_counter() + pipeline = AsyncPipeline( + ie=ie, model=model, plugin_config={}, device=device, max_num_requests=0 + ) + load_end_time = time.perf_counter() + + # Perform asynchronous inference + start_time = time.perf_counter() + + while next_frame_id < len(image_paths) - 1: + results = pipeline.get_result(next_frame_id_to_show) + + if results: + # Show next result from async pipeline + result, meta = results + display_handle = showarray(result, display_handle) + next_frame_id_to_show += 1 + if pipeline.is_ready(): + # Submit new image to async pipeline + image_path = image_paths[next_frame_id] + if reader is None: + image = cv2.imread(filename=str(image_path), flags=cv2.IMREAD_UNCHANGED) + else: + image = reader(str(image_path)) + pipeline.submit_data( + inputs={input_layer: image}, id=next_frame_id, meta={"frame": image} + ) + del image + next_frame_id += 1 + else: + # If the pipeline is not ready yet and there are no results: wait + pipeline.await_any() + + pipeline.await_all() + + # Show all frames that are in the pipeline after all images have been submitted + while pipeline.has_completed_request(): + results = pipeline.get_result(next_frame_id_to_show) + if results: + result, meta = results + display_handle = showarray(result, display_handle) + next_frame_id_to_show += 1 + + end_time = time.perf_counter() + duration = end_time - start_time + fps = len(image_paths) / duration + print(f"Loaded model to {device} in {load_end_time-load_start_time:.2f} seconds.") + print(f"Total time for {next_frame_id} frames: {duration:.2f} seconds, fps:{fps:.2f}") + + del pipeline.exec_net + del pipeline + + +# ## OpenVINO Tools + +# In[ ]: + + +def benchmark_model( + model_path: PathLike, + device: str = "CPU", + seconds: int = 60, + api: str = "async", + batch: int = 1, + cache_dir: PathLike = "model_cache", +): + """ + Benchmark model `model_path` with `benchmark_app`. Returns the output of `benchmark_app` + without logging info, and information about the device + + :param model_path: path to IR model xml file, or ONNX model + :param device: device to benchmark on. For example, "CPU" or "MULTI:CPU,GPU" + :param seconds: number of seconds to run benchmark_app + :param api: API. Possible options: sync or async + :param batch: Batch size + :param cache_dir: Directory that contains model/kernel cache files + """ + ie = IECore() + model_path = Path(model_path) + if ("GPU" in device) and ("GPU" not in ie.available_devices): + raise ValueError( + f"A GPU device is not available. Available devices are: {ie.available_devices}" + ) + else: + benchmark_command = f"benchmark_app -m {model_path} -d {device} -t {seconds} -api {api} -b {batch} -cdir {cache_dir}" + display( + Markdown( + f"**Benchmark {model_path.name} with {device} for {seconds} seconds with {api} inference**" + ) + ) + display(Markdown(f"Benchmark command: `{benchmark_command}`")) + + benchmark_output = get_ipython().run_line_magic("sx", "$benchmark_command") + benchmark_result = [ + line + for line in benchmark_output + if not (line.startswith(r"[") or line.startswith(" ") or line == "") + ] + print("\n".join(benchmark_result)) + print() + if "MULTI" in device: + devices = device.replace("MULTI:", "").split(",") + for single_device in devices: + device_name = ie.get_metric( + device_name=single_device, metric_name="FULL_DEVICE_NAME" + ) + print(f"{single_device} device: {device_name}") + else: + print(f"Device: {ie.get_metric(device_name=device, metric_name='FULL_DEVICE_NAME')}") + + +# ## Checks and Alerts +# +# Create an alert class to show stylized info/error/warning messages and a `check_device` function that checks whether a given device is available. + +# In[ ]: + + +class NotebookAlert(Exception): + def __init__(self, message: str, alert_class: str): + """ + Show an alert box with the given message. + + :param message: The message to display. + :param alert_class: The class for styling the message. Options: info, warning, success, danger. + """ + self.message = message + self.alert_class = alert_class + self.show_message() + + def show_message(self): + display(HTML(f"""
{self.message}""")) + + +class DeviceNotFoundAlert(NotebookAlert): + def __init__(self, device: str): + """ + Show a warning message about an unavailable device. This class does not check whether or + not the device is available, use the `check_device` function to check this. `check_device` + also shows the warning if the device is not found. + + :param device: The unavailable device. + :return: A formatted alert box with the message that `device` is not available, and a list + of devices that are available. + """ + ie = IECore() + supported_devices = ie.available_devices + self.message = ( + f"Running this cell requires a {device} device, " + "which is not available on this system. " + ) + self.alert_class = "warning" + if len(supported_devices) == 1: + self.message += f"The following device is available: {ie.available_devices[0]}" + else: + self.message += ( + "The following devices are available: " f"{', '.join(ie.available_devices)}" + ) + super().__init__(self.message, self.alert_class) + + +def check_device(device: str) -> bool: + """ + Check if the specified device is available on the system. + + :param device: Device to check. e.g. CPU, GPU + :return: True if the device is available, False if not. If the device is not available, + a DeviceNotFoundAlert will be shown. + """ + ie = IECore() + if device not in ie.available_devices: + DeviceNotFoundAlert(device) + return False + else: + return True + + +def check_openvino_version(version: str) -> bool: + """ + Check if the specified OpenVINO version is installed. + + :param version: the OpenVINO version to check. Example: 2021.4 + :return: True if the version is installed, False if not. If the version is not installed, + an alert message will be shown. + """ + installed_version = openvino.inference_engine.get_version() + if version not in installed_version: + NotebookAlert( + f"This notebook requires OpenVINO {version}. " + f"The version on your system is: {installed_version}.
" + "Please run pip install --upgrade -r requirements.txt " + "in the openvino_env environment to install this version. " + "See the " + "OpenVINO Notebooks README for detailed instructions", + alert_class="danger", + ) + return False + else: + return True +