ium/IUM_05.Biblioteki_DL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Biblioteki Deep  Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plan na dziś\n",
    "Przegląd bibliotek DL:\n",
    "1. Tensorflow\n",
    "2. Pytorch\n",
    "3. Caffe \n",
    "4. Caffe2\n",
    "5. Deeplearning4J\n",
    "6. CNTK (Microsoft Cognitive Toolkit)\n",
    "7. ML.NET\n",
    "8. MXNet\n",
    "9. Porównanie\n",
    "10. Formaty wymiany modeli\n",
    "\n",
    "Zadanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dynamiczne vs statyczne grafy obliczeniowe\n",
    "\n",
    "- Żeby wytrenować sieć neuronową, musimy skonstruować graf obliczeniowy\n",
    "- Graf może być:\n",
    "  - statyczny - definiowany raz dla wszystkich danych wejściowych\n",
    "  - dynamiczny - zmienny, w zależności od danych wejściowych\n",
    "- Zalety grafu dynamicznego:\n",
    "  - bardziej elastyczny i interaktywny - nie musimy kompilować grafu przed jego uruchomieniem\n",
    "  - łatwiejszy w debudowaniu\n",
    "- Zalety grafu statycznego:\n",
    "  - szybszy - łatwiej zaptymalizować\n",
    "  - przenośny - łatwiej go \"wyeksportować\" - graf zawiera wszystkie informacje konieczne do inferencji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1. Tensorflow\n",
    " - www.tensorflow.org\n",
    " - Open source\n",
    " - Rozwijana przez google\n",
    " - Bogaty \"ekosystem\"\n",
    " - Napisana w C/C++ i Pythonie\n",
    " - Liczne interfejsy/bindingi: Python, Java, Javascript (poprzez Tensorflow.js), Go, Rust, Swift\n",
    " - Łatwy do osadzenia dzięki Tensorflow Lite - runtime dla urządzeń mobilnych (C,C++,Java,Swift, Objective-C)\n",
    " - \"Serwowanie\" modeli przez REST API dzięki [Tensorflow Serving](https://www.tensorflow.org/tfx/guide/serving)\n",
    " - Trenowanie na GPU, TPU. Distributed training\n",
    " - Statyczny graf obliczeń, ale of wersji 2.0 dostępne \"Eager execution\", które umożliwia wykonywanie operacji w sieci bez budowania grafu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1.1 Keras\n",
    " - [keras.io](https://keras.io/)\n",
    " - Wysokopoziomowy interfejs do Tensorflow 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przykład IRIS w Tensorflow/Keras\n",
    "https://www.tensorflow.org/tutorials/customization/custom_training_walkthrough"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2. PyTorch\n",
    " - https://pytorch.org/\n",
    " - Open source (licencja BSD)\n",
    " - Napisana w Pythonie i C++\n",
    " - Interfejs w Python (oraz C++)\n",
    " - Rozwijany przez Facebook jako kontynywacja projektu Torch, napisanego w Lua/C/C++\n",
    " - Bogaty \"ekosystem\"\n",
    " - Dynamiczny graf obliczeń\n",
    " - Możliwość osadzenia na urządzeniach Android i iOS ([Torch mobile](https://pytorch.org/mobile/home/))\n",
    " - Serwowanie modeli przez REST dzięki [TorchServe](https://pytorch.org/serve/)\n",
    " - Przykład klasyfikacji IRIS w PyTorch: https://www.kaggle.com/aaditkapoor1201/iris-classification-pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3. Caffe\n",
    " - http://caffe.berkeleyvision.org/\n",
    " - Rozwijana przez [Berkley AI Research](https://bair.berkeley.edu/)\n",
    " - OpenSource (licencja BSD)\n",
    " - Napisany w C++\n",
    " - Interfejs w C++, Python, Matlab\n",
    " - Używana głównie do ropoznawania obrazów, ale nie tylko"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4. Caffe2\n",
    " - https://caffe2.ai/\n",
    " - Rozwijana przez Facebook\n",
    " - zmergowana do repozytorium PyTorch\n",
    " - Open source\n",
    " - Głównie zastosowania produkcyjne, w tym modele embedded (Caffe2go)\n",
    " - PyTorch: łatwość ekspoerymentowania, research. Caffe2: wydajność, urządzenia mobilne\n",
    " - ONNX jako format wymiany między Caffe2 i PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 5. Deeplearning4J\n",
    " - aka. DL4J, Deep Learning for Java\n",
    " - https://deeplearning4j.org/\n",
    " - Rozwijana przez [Eclipse Foundation](https://www.eclipse.org/)\n",
    " - Open source (licencja Apache 2.0)\n",
    " - Napisana w Javie i C++\n",
    " - Interfejsy: Java, Scala, Clojure, Kotlin\n",
    " - Możliość importu modeli Keras\n",
    " - Przykład klasyfikacji IRIS: https://deeplearning4j.konduit.ai/android/linear-classifier\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6. CNTK (Microsoft Cognitive Toolkit)\n",
    "- https://cntk.azurewebsites.net/\n",
    "- Rozwijana przez ... Microsoft (Rozwój porzucony w 2019 roku)\n",
    "- Open source (licencja MIT)\n",
    "- Napisana w C++\n",
    "- API: Python, C#, C++"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7. ML.NET\n",
    " - https://dot.net/ml\n",
    " - Rozwijana przez Microsoft\n",
    " - Open source (licencja MIT)\n",
    " - Napisana w C#, C++\n",
    " - API: .NET, Python (bindingi poprzez [NimbusML](https://github.com/microsoft/NimbusML))\n",
    " - Przykłady klasyfikacji IRIS:\n",
    "     - https://docs.microsoft.com/pl-pl/dotnet/machine-learning/tutorials/iris-clustering\n",
    "     - https://github.com/dotnet/machinelearning-samples/tree/main/samples/csharp/getting-started/MulticlassClassification_Iris\n",
    " - Więcej przykładów: https://github.com/dotnet/machinelearning-samples\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8. MXNet\n",
    " - https://mxnet.apache.org/\n",
    " - Open source (Apache 2.0)\n",
    " - Rozwijana przez [Apache Software Foundation](https://www.apache.org/)\n",
    " - Backend napisany w C++\n",
    " - Iterfejsy: Python (główny) i dodatkowo for Scala, Julia, Clojure, Java, C++, R i Perl\n",
    " - Możliwość osadzenia na urządzeniach mobilnych dzięki [amalgamacji](https://mxnet.apache.org/versions/1.8.0/api/faq/smart_device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9. Porównanie\n",
    "|Framework    |Autor       |Licencja  | Język     | Interface                  |Uwagi |\n",
    "|-------------|------------|----------|-----------|----------------------------|------|\n",
    "|Tensorflow   |Google      |Apache 2.0|C++, Python|C,C++,Python,Java,Javascript|      |\n",
    "|Keras        |Google      |MIT       |Python     |Python                      |Wysokopoziomowy interfejs do Tensorflow|\n",
    "|Tensorflow JS|Google      |Apache 2.0|Javascript |Javascript                  |      |\n",
    "|PyTorch      |Facebook    |BSD       |C++,Python |C,Python, Java              |      |\n",
    "|Caffe        |[BAIR](https://bair.berkeley.edu/)|BSD|C++|Python,Matlab| |\n",
    "|Caffe2       |Facebook    |BSD       |C++        |C++,Python                  |Od 3 lat (2018) część PyTorch|\n",
    "|CNTK         |Microsoft   |MIT       |C++        |Python, C++, C#             |od 01.2019 nierozwijana|\n",
    "|ML.NET       |Microsoft   |MIT       |C++, C##   |.NET, Python                ||        \n",
    "|MXNet        |Apache Foundation|Apache 2.0|C++, Python|Python, Scala, Julia, Clojure, Java, C++, R i Perl||"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9. Formaty wymiany\n",
    " - większość bibliotek używa innego formatu do zapisu modeli\n",
    " - istnieją otwarte, uniwersalne formaty zapisu modeli sieci neuronowych, które mają za zadanie umożliwienie dzielenia modeli między bibliotekami\n",
    " - Lista operacji wspieranych przez formaty nie zawiera wszystkich operacji używanych przez różna biblioteki, dlatego czasami kownwersja do ONNX nie jest w pełni możliwa\n",
    " - ONNX - Open Neural Network Exchange\n",
    "   - https://onnx.ai/\n",
    "   - utrzymywany przez \"społeczność\"\n",
    "   - narzędzia umożliwiające konwersję do formatu ONNX modeli z [najpopularniejszych bibliotek NN/ML](https://onnx.ai/supported-tools.html)\n",
    "   - modele ONNX mogą być uruchomione (czasami po konwersji) przy pomocy wielu runtimów\n",
    " - NNEF - Neural Network Exchange Format\n",
    "   - https://www.khronos.org/nnef/\n",
    "   - wspierany przez Khronos Group (Nvidia, ATI, Intel, Sun, ...) - ta sama, która rozwija OpenGL\n",
    "   - konwersja z/do ONNX, Caffe, Caffe2, TensorFlow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Zadanie [20 pkt.]\n",
    "\n",
    "Termin: 2 tygodnie (25 IV)\n",
    "\n",
    "1. Wybierz jeden z frameworków ML (jeden z powyższych, ale może być też inny) i zaimplementuj w nim prostą sieć neuronową rozwiązującą wybrany problem (np regresji lub klasyfikacji) na wybranym na poprzednich zajęciach zbiorze. Możesz wzorować się (lub nawet skopiować) na jednym z tutotoriali do danego frameworka.\n",
    "    - wczytaj dane trenujące z pliku [2 pkt.]\n",
    "    - wytrenuj na nich model [8 pkt.]\n",
    "    - przy jego pomocy dokonaj klasyfikacji/regresji na danych ze zbioru testującego [8 pkt.]\n",
    "    - zapisz wyniki zwrócone przez model do pliku [2 pkt.]<br>\n",
    "   Uwagi:\n",
    "    - wyniki nie są najważniejsze - o ile twój model nie zwraca losowych danych ;)\n",
    "    - nie musisz wnikać głęboko w szczegóły trenowania modelu i inferencji. W tym zadaniu chodzi o poznanie API i praktycznych aspektów\n",
    "    - kod i stworzony model będziemy wykorzystywać na następnych zajęciach \n",
    "\n",
    "\n",
    "2. Dostosuj Dockerfile przygotowany na poprzednich zajęciach tak, żeby móc w zdefiniowanym w nim kontenerze wytrenować i uruchomić sieć przygotowaną w punkcie 1 [2 pkt.]"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}