woche2/notebooks/intro-tensorflow-keras/intro-tensorflow-keras.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "intro-tensorflow-keras.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "pycharm": {
      "stem_cell": {
        "cell_type": "raw",
        "source": [],
        "metadata": {
          "collapsed": false
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ZBGfn2537Vd",
        "colab_type": "text"
      },
      "source": [
        "# Einführung Tensorflow/Keras"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgqbFDDM4Ifh",
        "colab_type": "text"
      },
      "source": [
        "## Keras sequential model API"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yxOOgazUG2LS",
        "colab_type": "text"
      },
      "source": [
        "Das sequentielle Model ist **ein linearer Stapel** von Schichten (von Neuronen).\n",
        "\n",
        "**Import**\n",
        "```python\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Activation\n",
        "```\n",
        "\n",
        "Man kann ein sequentielles Model erstellen, indem man an den Konstruktor eine **Liste der Schichten** übergibt, die man nutzen will:\n",
        "```python\n",
        "model = Sequential([\n",
        "    Dense(32, input_dim=784), \n",
        "    Activation('linear'),\n",
        "])\n",
        "```\n",
        "\n",
        "* `Dense()` ist eine \"dichte\" Schicht, jedes Neuron ist mit jedem Neuron der folgenden Schicht verbunden\n",
        "  * `Dense(32)` bedeutet, dass diese Schicht aus 32 Neuronen besteht\n",
        "  * `input_dim=784` ist die Spezifizierung der Eingabeform\n",
        "    * bedeutet, die Eingabe soll ein 784-dimensionaler Vektor sein\n",
        "* `Activation()` ist die Angabe der Aktivierungsfunktion der Neuronen (Erinnerung an die Treppenfunktion)\n",
        "  * `Activation('linear')` ist die lineare Aktivierungsfunktion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wLAUv2rhLeTe",
        "colab_type": "text"
      },
      "source": [
        "### Alternative Schreibweise (add-Funktion)\n",
        "Wir können das Gleiche erreichen durch die `.add()` - Funktion:\n",
        "```python\n",
        "model = Sequential()\n",
        "model.add(Dense(32, input_dim=784))\n",
        "model.add(Activation('linear'))\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QeGvCO8hN9nc",
        "colab_type": "text"
      },
      "source": [
        "### Model konfigurieren und kompilieren\n",
        "\n",
        "**`compile` - Funktion:**\n",
        "* Konfiguration des Models\n",
        "  * Wir **müssen** einen **Optimizer** angeben (sonst kann das Netz nicht lernen).\n",
        "  * auch eine Fehlerfunktion und eine Metrik (Messen der Genauigkeit) können wir angeben\n",
        "  * *Die weiteren Parameter brauchen wir an dieser Stelle nicht.*\n",
        "  * *Fortgeschrittene Teilnehmer finden deren Definition hier:* [Keras Dokumentation](https://keras.io/models/model/#compile)\n",
        "\n",
        "```python\n",
        "model.compile(optimizer, loss=None, metrics=None, loss_weights=None, sample_weight_mode=None, weighted_metrics=None, target_tensors=None)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9PEfQwJEOBni",
        "colab_type": "text"
      },
      "source": [
        "### Model trainieren\n",
        "\n",
        "**`fit` - Funktion:**\n",
        "* Training des Models\n",
        "    * Wir übergeben \n",
        "        * die **Eingabedaten** (Array oder Liste)\n",
        "        * die **Ziel-Daten** (gewünschtes Ergebnis pro Eintrag)\n",
        "    * Die *Batch-Größe* beschreibt wie viele Einträge druch das Netz gefüttert werden, bevor der Gradient für die nächste Anpassung berechnet wird.\n",
        "    * Eine *Epoche* ist eine vollständige Iteration über den gesamten Datensatz (alle Batches). Wir geben an, wie viele davon durchgeführt werden sollen.\n",
        "\n",
        "```python\n",
        "model.fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False)\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Abip37MZOGJ-",
        "colab_type": "text"
      },
      "source": [
        "### Model evaluieren\n",
        "\n",
        "**`evaluate` - Funktion:**\n",
        "* Evaluierung des Models\n",
        "    * Gibt die Fehler- und Genauigkeitsmetriken des Models zurück\n",
        "    * Berechnung jeweils pro Batch\n",
        "    * Wir übergeben (wie in der `fit` Funktion)\n",
        "      * die **Eingabedaten** (in diesem Falle die Trainingsdaten als Array oder Liste)\n",
        "      * die **Ziel-Daten** (gewünschtes Ergebnis pro Eintrag)\n",
        "\n",
        "```python\n",
        "model.evaluate(x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False)\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVEFcmb02ulZ",
        "colab_type": "text"
      },
      "source": [
        "### Model trifft Vorhersagen\n",
        "\n",
        "**`predict` - Funktion:**\n",
        "* Vorhersagungen des Models\n",
        "  * Vorhersage der Labels der Testdaten (noch nicht gesehene Daten)\n",
        "  * Berechnung erfolgt wieder auf Batches (deren Größe wir angeben sollten).\n",
        "\n",
        "```python\n",
        "model.predict(x, batch_size=None, verbose=0, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gN9RmOcm4Qqc",
        "colab_type": "text"
      },
      "source": [
        "## Keras functional model API"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kMvn6CeGN1_Z",
        "colab_type": "text"
      },
      "source": [
        "Die Keras functional API bietet mehr Freiheiten in der **Definition komplexer neuronaler Netze**.\n",
        "\n",
        "Die functional API wird in der Praxis häufiger genutzt als die sequential model API, da diese mehr für einfache Netze geeignet ist."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "myN8aocVVaKv",
        "colab_type": "text"
      },
      "source": [
        "### Beispiel an einem vollständig verbundenem Netzwerk\n",
        "\n",
        "*Eigentlich wäre für dieses einfache Netz die Sequential model API vollkommen ausreichend, aber an so einem Beispiel kann man die API besser verstehen.*\n",
        "\n",
        "Eine `layer`-Instanz ist aufrufbar auf einem `tensor`. Die Rückgabe ist ein Eingabetensor und ein Ausgabetensor. Das kann genutzt werden, um ein Modell zu definieren, genau wie in der *sequentiall model API*.\n",
        "\n",
        "**Import:**\n",
        "```python\n",
        "from keras.layers import Input, Dense\n",
        "from keras.models import Model\n",
        "```\n",
        "**Eingabe definieren:**\n",
        "```python\n",
        "# gibt Tensor zurück\n",
        "inputs = Input(shape=(784,))\n",
        "```\n",
        "**`layer` Instanzen aufrufen**:\n",
        "* können hier beliebige Schichten kombinieren\n",
        "\n",
        "```python\n",
        "# eine Schicht ist aufrufbar auf einem tensor und gibt einen tensor zurück\n",
        "output_1 = Dense(64, activation='linear')(inputs)\n",
        "output_2 = Dense(64, activation='linear')(output_1)\n",
        "predictions = Dense(10, activation='linear')(output_2)\n",
        "```\n",
        "**Model erstellen:**\n",
        "```python\n",
        "# Erstellt ein Model mit einer Eingabeschicht und drei \"Dense\" Schichten\n",
        "model = Model(inputs=inputs, outputs=predictions)\n",
        "```\n",
        "**Model konfigurieren**:\n",
        "```python\n",
        "model.compile(optimizer='', loss='', metrics=[''])\n",
        "```\n",
        "**Model trainieren**:\n",
        "\n",
        "```python\n",
        "model.fit(data, labels)  # beginnt Training\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sd8JoU1LZFZE",
        "colab_type": "text"
      },
      "source": [
        "### Wiederverwendung von Models\n",
        "Alle `model` sind aufrufbar, genau wie `layer`\n",
        "\n",
        "Dadurch ist es mit der functional API sehr einfach möglich Modele wiederzuverwenden:\n",
        "* ein `model` kann wie eine `layer` behandelt werden und auf einem `tensor` aufgerufen werden\n",
        "\n",
        "**Merke:** Man verwendet nicht nur den Aufbau des Models, sondern auch die Gewichte!\n",
        "\n",
        "```python\n",
        "x = Input(shape=(784,))\n",
        "y = model(x)\n",
        "```\n",
        "\n",
        "**Vorteil:** Man kann sehr schnell Modelle bauen, die verschiedene Eingaben entgegennehmen."
      ]
    }
  ]
}