Introduzione_TensorFlow_v2_parte2_ITA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "yQPsHM4WNYje",
        "Vs3sxPYBC7zG",
        "ilNqwkVdFMxI",
        "7yU-TXQpHLFe",
        "YiN4QylsWCgt",
        "NZzbsnY6l156"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Tensorflow v2 per costruire una rete neurale\n",
        "\n",
        "\n",
        "Mario Fiorino\n",
        "\n",
        "\n",
        "Ref:\n",
        "\n",
        "https://www.tensorflow.org/guide\n",
        "\n",
        "\n",
        "https://www.tensorflow.org/guide/basics\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "tvmEIPc99ZM4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "print(\"TensorFlow version:\", tf.__version__)\n",
        "\n",
        "from keras import initializers\n",
        "import os\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from matplotlib import pyplot as plt"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s3oe4dcIUGxu",
        "outputId": "bfce1502-9432-4baa-fbd3-88c1d24e3fca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TensorFlow version: 2.15.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Un esempio semplice di architettura di rete neurale"
      ],
      "metadata": {
        "id": "yQPsHM4WNYje"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "l_in = 2  # 2 segnali di ingresso\n",
        "l_out = 5 # 5 nodi\n",
        "\n",
        "sx = tf.random.normal(shape=(1,l_in), mean=4.0, stddev=1.0)\n",
        "print(sx,\"\\n\") # segnali di imput\n",
        "\n",
        "W1 = tf.Variable( tf.random.normal((l_in, l_out), mean=1.0, stddev=0.1),name='Weight')\n",
        "print(W1,\"\\n\")\n",
        "b1 = tf.Variable(tf.ones([1, l_out]))\n",
        "print(b1,\"\\n\")\n",
        "\n",
        "comb = tf.matmul(sx, W1) # input * weight\n",
        "print(comb,\"\\n\")\n",
        "y = tf.add(comb, b1) # + bias\n",
        "print(y,\"\\n\")\n",
        "\n",
        "#activation functions\n",
        "print(tf.nn.softmax(y).numpy().round(2)) # uscite dei neuroni\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hmvSCfMafCp2",
        "outputId": "f93f4ecb-5c8a-4dc5-a4be-d2319bd20568"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([[2.279694  3.2052472]], shape=(1, 2), dtype=float32) \n",
            "\n",
            "<tf.Variable 'Weight:0' shape=(2, 5) dtype=float32, numpy=\n",
            "array([[0.9841063 , 0.9804101 , 0.99050623, 1.1790799 , 0.92844033],\n",
            "       [1.0198735 , 1.0048622 , 1.1197214 , 0.9504199 , 1.1197842 ]],\n",
            "      dtype=float32)> \n",
            "\n",
            "<tf.Variable 'Variable:0' shape=(1, 5) dtype=float32, numpy=array([[1., 1., 1., 1., 1.]], dtype=float32)> \n",
            "\n",
            "tf.Tensor([[5.5124083 5.455867  5.847035  5.734272  5.705745 ]], shape=(1, 5), dtype=float32) \n",
            "\n",
            "tf.Tensor([[6.5124083 6.455867  6.847035  6.734272  6.705745 ]], shape=(1, 5), dtype=float32) \n",
            "\n",
            "[[0.17 0.16 0.24 0.22 0.21]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Proviamo a fare qualcosa di più complesso.\n",
        "\n",
        "Costruiamo una rete neurale con TensorFlow per riconoscere le cifre scritte a mano, usando come dataset MIST (contiene migliaia di immagini di cifre scritte a mano)\n",
        "\n",
        "Per prima cosa, importiamo il dataset:"
      ],
      "metadata": {
        "id": "Vs3sxPYBC7zG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Importiamo il dataset"
      ],
      "metadata": {
        "id": "4U0Ks-3iHz8s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(xtrain,label_train),(xtest,label_test)=tf.keras.datasets.mnist.load_data()\n"
      ],
      "metadata": {
        "id": "C8piQ-pIWJJh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "51fb2fb4-0fe5-49ae-ab84-84c6de120572"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11490434/11490434 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Verifichiamo il contenuto"
      ],
      "metadata": {
        "id": "RjZkwIhyngJo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(xtrain.shape)\n",
        "print(len(xtrain)) # len = 60000\n",
        "print(label_train.shape) # len = 60000\n",
        "print(\"\")\n",
        "print(label_test.shape)\n",
        "print(xtest.shape)\n",
        "\n",
        "print(\"\\nRaw Image shape:\",xtrain[0].shape)\n",
        "print(\"\")\n",
        "plt.figure(figsize=[2, 2])\n",
        "for i in range(0, 9):\n",
        "    plt.subplot(330 + 1 + i)\n",
        "    plt.imshow(xtrain[i], cmap=plt.get_cmap('gray'))\n",
        "    print(\"Label:\",label_train[i], end =\"  \")\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 398
        },
        "id": "07VOQnz8hZ0F",
        "outputId": "aac21a26-c163-44ff-b4c7-5f939dd959e4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(60000, 28, 28)\n",
            "60000\n",
            "(60000,)\n",
            "\n",
            "(10000,)\n",
            "(10000, 28, 28)\n",
            "\n",
            "Raw Image shape: (28, 28)\n",
            "\n",
            "Label: 5  Label: 0  Label: 4  Label: 1  Label: 9  Label: 2  Label: 1  Label: 3  Label: 1  "
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 200x200 with 9 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Data Preparation**\n",
        "\n",
        "Per creare un modello di rete neurale multistrato efficiente per la classificazione di immagini, si è soliti applicare alcuni pre-trattamenti al dataset:\n",
        "\n",
        "- Flatten : Le immagini, che sono matrici bidimensionali (28x28 pixel), vengono convertite in vettori unidimensionali di lunghezza 784 (cioè 28 * 28). In questo modo, ogni pixel diventa un elemento del vettore.\n",
        "\n",
        "- Normalizzazione : I valori di scala di grigio, che normalmente vanno da 0 a 255, vengono ridimensionati tra 0 e 1. Questo facilita l'apprendimento della rete neurale.\n",
        "\n",
        "- Codifica binaria: Le categorie di classificazione (da 1 a 9) vengono trasformate in una matrice binaria. Ad esempio, la categoria \"3\" diventa una matrice con 1 nella terza posizione e 0 nelle altre."
      ],
      "metadata": {
        "id": "wezk7c2EineC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num_pixels = (xtrain[0].shape[0]) * (xtrain[0].shape[0])\n",
        "print(num_pixels,\"\\n\")\n",
        "\n",
        "# flatten 28*28 pixel images to a 784 vector\n",
        "xtrain = xtrain.reshape(xtrain.shape[0], num_pixels).astype('float32')\n",
        "xtest = xtest.reshape(xtest.shape[0], num_pixels).astype('float32')\n",
        "\n",
        "# normalize inputs from 0-255 to 0-1\n",
        "xtrain = xtrain / 255\n",
        "xtest = xtest / 255\n",
        "print(xtrain[0].shape,\"\\n\")\n",
        "\n",
        "# one hot encode outputs\n",
        "label_train = tf.keras.utils.to_categorical(label_train) # utils is tools for creating one-hot encoding\n",
        "label_test = tf.keras.utils.to_categorical(label_test)\n",
        "print(label_train[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xezOYJl3jzJd",
        "outputId": "2114f448-14b9-49e9-c6ef-b224c1a41f1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "784 \n",
            "\n",
            "(784,) \n",
            "\n",
            "[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Definizione dell'architettura della rete neurale"
      ],
      "metadata": {
        "id": "1De4I6U3HevN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# codice di riferimento\n",
        "# https://medium.com/analytics-vidhya/how-to-write-a-neural-network-in-tensorflow-from-scratch-without-using-keras-e056bb143d78\n",
        "\n",
        "class NN(object):\n",
        "\n",
        "\tdef __init__(self, n_layers): # n_layers è una lista in cui sono presenti il numero di nodi per ogni layer della rete\n",
        "\n",
        "\t\t# Contenitore per registrare i parametri della NN\n",
        "\t\tself.params = []\n",
        "\n",
        "\t\t# Inizializza tutte le matrice sia dei pesi che dei bias\n",
        "\t\t#Layer1\n",
        "\t\tself.W1 = tf.Variable(tf.random.normal([n_layers[0], n_layers[1]], mean=0.0, stddev=0.1),name='W1')\n",
        "\t  #NOTA [n_layers[0], n_layers[1]] = (dim_input, numero_di_nodi)\n",
        "\t\tself.b1 = tf.Variable(tf.zeros([1, n_layers[1]]),name='b1')\n",
        "\t  #Alternativa bias\n",
        "\t  #self.b1 = tf.Variable(tf.random.normal([n_layers[1]], mean=0.0, stddev=0.1, dtype=tf.dtypes.float32, seed=0), name='b1')\n",
        "\n",
        "    #Layer2\n",
        "\t\tself.W2 = tf.Variable(tf.random.normal([n_layers[1], n_layers[2]], mean=0.0, stddev=0.1),name='W2')\n",
        "\t\tself.b2 = tf.Variable(tf.zeros([1, n_layers[2]]),name='b2')\n",
        "\n",
        "    #Layer3\n",
        "\t\tself.W3 = tf.Variable(tf.random.normal([n_layers[2], n_layers[3]], mean=0.0, stddev=0.1),name='W3')\n",
        "\t\tself.b3 = tf.Variable(tf.zeros([1, n_layers[3]]),name='b3')\n",
        "\n",
        "\t\t# Conserva tutti i pesi e i bias della NN in self.params\n",
        "\t\tself.params = [self.W1, self.b1, self.W2, self.b2, self.W3, self.b3]\n",
        "\t\t#print(self.params)\n",
        "\n",
        "\n",
        "\tdef forward(self, x):\n",
        "\t\t# Costruzione della NN\n",
        "\t\t# un esempio dal dataset ->  label predetta\n",
        "\t\tZ1 = tf.matmul(x, self.W1) + self.b1 # Z1 = tf.matmul(X_tf, self.W1) + self.b1\n",
        "\t\tZ1 = tf.nn.relu(Z1)\n",
        "\t\tZ2 = tf.matmul(Z1, self.W2) + self.b2\n",
        "\t\tZ2 = tf.nn.relu(Z2)\n",
        "\t\tlogit = tf.matmul(Z2, self.W3) + self.b3\n",
        "\t\t# I logit sono gli output di una rete neurale prima che venga applicata la funzione di attivazione.\n",
        "\t\tY = tf.nn.softmax(logit)\n",
        "\t\treturn Y  #Alternativa:  logit,Y\n",
        "\n",
        "\tdef loss(self, y_true , l_pred):\n",
        "\t\t# Funzione di loss: cross-entropy\n",
        "\t\t# Parametri di input:\n",
        "\t\t# logits ovvero i valori predetti dalla nostra rete su cui sarà applicata la softmax fuction\n",
        "\t\t# Label, cioè i valori effettivi\n",
        "\n",
        "\t\ty_true_tf = tf.reshape(y_true, [1, 10])\n",
        "\t\tl_pred_tf = l_pred\n",
        "\n",
        "\t\tlce = tf.keras.losses.CategoricalCrossentropy(from_logits=False)(y_true_tf,l_pred_tf)\n",
        "\t\t#Potenziale alternativa manuale, da valutare = -tf.reduce_sum(y_true_tf * np.log2(l_pred_tf))\n",
        "\t\treturn lce\n",
        "\n",
        "\n",
        "\tdef backward(self, x,y):\n",
        "\t\t# Processo di \"aggiustamento\" dei pesi attraverso la minimizzazione della loss\n",
        "\n",
        "\t\t#1.\n",
        "\t\t# Create an optimizer with the desired parameters\n",
        "\t\topt = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
        "\t\t#Alternativa:\n",
        "\t\t#opt = tf.keras.optimizers.SGD(learning_rate=0.01)\n",
        "\n",
        "    #2.\n",
        "\t\t# Compute the gradients of: \"current_loss\" for a list of variables given: \"self.params\"\n",
        "\t\twith tf.GradientTape() as tape:\n",
        "\t\t\t\ty_predicted = self.forward(x)\n",
        "\t\t\t\tcurrent_loss = self.loss(y, y_predicted)\n",
        "\t\tgradienti = tape.gradient(current_loss, self.params)\n",
        "\n",
        "    #3.\n",
        "\t\t#Ask the optimizer to update a list of variables, given a list of gradients.\n",
        "\t\topt.apply_gradients(zip(gradienti, self.params))\n",
        "\n",
        "\t\t# https://www.tensorflow.org/api_docs/python/tf/compat/v1/train/Optimizer\n",
        "\t\t# https://www.tensorflow.org/api_docs/python/tf/keras/Optimizer\n",
        "\n",
        "\tdef accuracy(self):\n",
        "\t\tc=0\n",
        "\t\tlt = len(xtest)\n",
        "\n",
        "\t\tfor i in range(lt):\n",
        "\t\t\tx = tf.reshape(xtest[i], [1, -1])\n",
        "\t\t\tpredicted_digit = tf.argmax(self.forward(x),1)\n",
        "\t\t\tactual_digit = tf.argmax(label_test[i])\n",
        "\t\t\tif predicted_digit.numpy()[0] == actual_digit.numpy():\n",
        "\t\t\t\tc = c + 1\n",
        "\t\treturn (\"Accuracy su tutto il test dataset :\", c/lt)"
      ],
      "metadata": {
        "id": "B9Y2wXwoKj58"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Approfondimenti Tecnici\n",
        "\n",
        "\n",
        "**Softmax function**\n",
        "\n",
        "La funzione Softmax è una funzione che trasforma un certo vettore di $K$ valori reali in un vettore di $K$ valori reali la cui somma è 1. I valori di input possono essere positivi o negativi, ma softmax li trasforma in valori compresi tra 0 e 1 , in modo che possano essere interpretati come probabilità. Formula:\n",
        "\n",
        "$\\sigma(\\textbf{z})_i = \\frac{e^{z_{i}}}{\\sum_{j=1}^K e^{z_{j}}} \\ \\ \\ per \\ i=1,2,\\dots,K$\n",
        "\n",
        "Dove, dato il vettore di input $\\textbf{z} = (z_1, z_2, ... , z_K)$ , in uscita avremo un vettore del tipo = $(\\sigma(\\textbf{z})_1, \\sigma(\\textbf{z})_2, ...,  \\sigma(\\textbf{z})_K)$\n",
        "\n",
        "$\\;$\n",
        "\n",
        "**Cross-Entropy Loss**\n",
        "\n",
        "Ref: https://machinelearningmastery.com/cross-entropy-for-machine-learning/\n",
        "\n",
        "\n",
        "In termini generali la cross-entropy misura la distanza tra due distribuzioni di probabilità.\n",
        "\n",
        "\n",
        "Questa è spesso usata come funzione di loss, nei problemi di classificazione, per calcolare quanto sia accurato il nostro modello: definendo la differenza tra la probabilità stimata e il risultato desiderato.\n",
        "\n",
        "Sia indicato con  ${\\displaystyle t_{i}}$ la vera distribuzione di probabilità (in pratica i \"true labels\"), e sia ${\\displaystyle q_{i}}$  la distribuzione prevista dal modello (il valore che produce in uscita la NN); sia infine $C$ il numero delle classi disponibili, formalmente si definisce:\n",
        "\n",
        "$Loss_{CE}(t_{i}, q_{i}) = -\\sum_{i}^C {t_{i} \\log{q_{i}}}$\n",
        "\n",
        "Tipicamente il $\\log$ è a base $2$.\n",
        "\n",
        "Ad esempio, in un problema di classificazione binaria, dove $C = 2$, sono presenti due classi complementari, spesso denominate classe positiva (1) e classe negativa (0). La cross-entropy loss può essere definita anche come:\n",
        "\n",
        "$ Loss_{CE} (t_{i}, q_{i}) = -\\sum_{i=1}^{2}t_{i} \\log{q_{i}} = -t_{1}log(q_{1})-(1-t_{1}) log(1-q_{1})$\n",
        "\n",
        "L’output del modello NN $q_{1}$ rappresenta la probabilità prevista che un certo evento appartenga alla classe positiva ; mentre $t_{1}$ è l'effettiva distribuzione (Nota essendo le classi complementari lo stesso discorso puo esser fatto per la classe negativa).\n",
        "\n",
        "Per capirci meglio con un esempio pratico:\n",
        "\n",
        "Primo campione rilevato, il modello NN dice che ha la seguente probablità di appartenere alla classe positiva : $q_{1} = 0.8$; il campione appartine alla classe postiva (la \"true label\"), quindi $t_{1}= 1$ ; la relativa funzione di loss vale:\n",
        "\n",
        "$ Loss_{CE} (ClassePositiva, 0.8)= -1 \\cdot \\log(0.8)-(1-1) \\log(1-0.8) = 0.22 $.\n",
        "\n",
        "Secondo campione: $q_{1} = 0.3$ ; $t_{1}= 0$ ;\n",
        "\n",
        "$ Loss_{CE} (ClassePositiva, 0.3) = 0 \\cdot \\log(0.3)-(1-0) \\log(1-0.3) = 0.35 $.\n",
        "\n",
        "...\n",
        "\n",
        "\n",
        "Se invece si desidera distinguere tra più di due classi, cioè supponiamo che stiamo costruendo un classificatore di colori con tre classi: verde, giallo e rosso. In questo caso, $C=3$. Siano date le seguenti \"true label\":\n",
        "\n",
        "verde (classe 1) è rappresento come $[1,0,0]$,\n",
        "\n",
        "giallo(classe 2) come $[0,1,0]$,\n",
        "\n",
        "rosso (classe 3) come $[0,0 ,1]$.\n",
        "\n",
        "Per un certo campione, la nostra NN da in uscita: $[0.8,0.1,0.1]$, la true label associata è verde; la cross-entropy Loss:\n",
        "\n",
        "$ Loss_{CE} ([1,0,0],[0.8,0.1,0.1]) = - ( 1 \\cdot \\log(0.8)+ 0 ⋅ \\log(0.1) + 0 ⋅ \\log(0.1)) = 0.22 $\n",
        "\n",
        "$\\;$\n",
        "\n",
        "Si ricordi che l'obiettivo delle tecniche di ottimizzazione per le reti neurali è minimizzare la funzione di perdita (loss) su tutti gli esempi del dataset di training. Valori della loss più piccoli indicano che le previsioni dalla rete neurale si allineano meglio con le etichette reali delle classi disponibili.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "$\\;$\n",
        "\n",
        "**tf.keras.losses.CategoricalCrossentropy(from_logits=False)()**\n",
        "\n",
        "Di solito, si applica una funzione di attivazione (Sigmoid o Softmax) ai logits della rete neurale prima di calcolare la funzione di loss Cross-entropy.\n",
        "\n",
        "Nella figura sottostante, la lettera $s$ rappresenta i logits, ossia il risultato in uscita (un vettore) della rete neurale prima dell'applicazione della funzione di attivazione $f()_i$\n",
        "\n",
        "\n",
        "\n",
        "Utility:\n",
        "\n",
        "https://www.v7labs.com/blog/cross-entropy-loss-guide\n",
        "\n",
        "https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalCrossentropy\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ilNqwkVdFMxI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<div>\n",
        "<img src=\"data:image/png;base64,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\", width=\"400\">\n",
        "</div>"
      ],
      "metadata": {
        "id": "OwYlwiiph1Q8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_true = [[0, 1, 0], [0, 0, 1]]\n",
        "y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]\n",
        "\n",
        "cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)\n",
        "print(cce(y_true, y_pred).numpy())\n",
        "\n",
        "cce1 = tf.keras.losses.CategoricalCrossentropy(from_logits=False)\n",
        "print(cce1(y_true, y_pred).numpy())\n",
        "\n",
        "cce2 = tf.keras.losses.CategoricalCrossentropy(from_logits=False)\n",
        "print(cce2(y_true, tf.nn.softmax(y_pred) ).numpy())\n",
        "\n",
        "print(\"\")\n",
        "\n",
        "cce3 = tf.keras.losses.CategoricalCrossentropy(from_logits=False)\n",
        "print(cce3(y_true, tf.nn.sigmoid(y_pred) ).numpy())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cwz-9Pcv4UCV",
        "outputId": "c2e365a8-b621-4101-dc30-c00da4bbc4e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9868951\n",
            "1.1769392\n",
            "0.9868951\n",
            "\n",
            "1.0377035\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**tf.GradientTape**\n",
        "\n",
        "\n",
        "https://www.tensorflow.org/guide/autodiff\n",
        "\n"
      ],
      "metadata": {
        "id": "htrXulo7RwR-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = tf.Variable(3.0)\n",
        "\n",
        "with tf.GradientTape() as tape:  # Qui si prepara il set up per la differenziazione automatica (ovvero il calcolo del gradiente).\n",
        "  y = x**2\n",
        "\n",
        "dy_dx = tape.gradient(y, x)  #con l'istruzione \"\".gradient(target, sources)\" si concretizza il calcolo del gradiente di y rispetto la variabile x\n",
        "print(dy_dx.numpy())  # dy = 2x * dx\n",
        "\n",
        "#################\n",
        "print(\"\\n---\\n\")\n",
        "################\n",
        "\n",
        "w = tf.Variable(tf.random.normal((3, 2)), name='w')\n",
        "b = tf.Variable(tf.zeros(2, dtype=tf.float32), name='b')\n",
        "x = [[1., 2., 3.]]\n",
        "\n",
        "print(\"w = \",w)\n",
        "\n",
        "with tf.GradientTape(persistent=True) as tape:\n",
        "  y = x @ w + b\n",
        "  print(\"y = \", y)\n",
        "  loss = tf.reduce_mean(y**2)\n",
        "\n",
        "[dl_dw, dl_db] = tape.gradient(loss, [w, b]) # ricaviamo le derivate parziali della funzione loss\n",
        "#prima rispetto alla varaibile w e poi b\n",
        "print(\"\\ndl_dw = \",dl_dw)\n",
        "print(\"\\ndl_db = \",dl_db)\n",
        "print(\"\")\n",
        "print(dl_dw.shape ==  w.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jeDFRRFMPDxD",
        "outputId": "51b6942e-aaac-4a47-95f8-121757886583"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6.0\n",
            "\n",
            "---\n",
            "\n",
            "w =  <tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=\n",
            "array([[ 0.27944678, -2.4003227 ],\n",
            "       [ 0.33647862,  1.5452365 ],\n",
            "       [-0.5806951 , -0.8837646 ]], dtype=float32)>\n",
            "y =  tf.Tensor([[-0.7896812 -1.9611435]], shape=(1, 2), dtype=float32)\n",
            "\n",
            "dl_dw =  tf.Tensor(\n",
            "[[-0.7896812 -1.9611435]\n",
            " [-1.5793624 -3.922287 ]\n",
            " [-2.3690436 -5.8834305]], shape=(3, 2), dtype=float32)\n",
            "\n",
            "dl_db =  tf.Tensor([-0.7896812 -1.9611435], shape=(2,), dtype=float32)\n",
            "\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Adam : Adaptive Moment Estimation**\n",
        "\n",
        "Premessa:\n",
        "\n",
        "La discesa del gradiente (**Gradient Descent**) è un algoritmo iterativo che consente di determinare il valore dei minimi locali di una funzione convessa e differenziabile a più variabili. Nel  machine learning è utilizzato per addestrare modelli, minimizzando la funzione di loss (riducendo cioè l'errore tra i risultati predetti e quelli effettivi).\n",
        "L'idea è di sfruttare le derivata parziali (il gradiente) della funzione loss rispetto i vari parametri del modello, per poter aggiornare opportunamente il loro valore:\n",
        "\n",
        "$p_{n+1} = p_n - lr \\cdot \\nabla f_{\\text{Loss}} (p_n)$\n",
        "\n",
        "Dove\n",
        "\n",
        "$lr$ = learning rate\n",
        "\n",
        "$p_n$ indica il valore dei parametri del modello all $n$-essimo step iterativo. Si noti, per una NN tali parametri sono rappresentati dai weights e dai bias.\n",
        "\n",
        "Ripetendo questo aggiornamento in modo iterativo, ci si avvicina progressivamente ad un minimo locale della funzione di loss; per tanto il processo iterativo termina quando:\n",
        "\n",
        "$\\nabla f_{\\text{Loss}} (p_n) = 0 $.\n",
        "\n",
        "\n",
        "Maggiori info:\n",
        "https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21\n",
        "\n",
        "\n",
        "$\\;$\n",
        "\n",
        "\n",
        "**Stochastic Gradient Descent** (SGD) è una variazione del metodo Gradient Descent. Andando un pò più nello specifico, il gradient descent, spesso chiamato anche \"batch gradient descent\", per eseguire l'aggiornamento dei parametri del modello, calcola, ad ogni epoca o iterazione, i gradienti di tutte le funzioni loss ottenute usando tutti gli esempi contenuti nel training dataset, poi ne fa la media,  ed infine, aggiorna con il valore di questa, i parametri del modello.\n",
        "\n",
        "SGD invece, accelera (diminuisce il tempo di calcolo) questa prassi, calcolando, ad ogni epoca, solo il gradinte della funzione di loss per un singolo esempio, spesso estratto random dal training dataset.\n",
        "Si noti che in talune circostante si preferisce estrarre, non uno, ma un piccolo sottoinsieme di esempi detto \"mini-batch\", da questo ricavare la rispettive funzioni di loss, poi i rispettivi gradienti, farne la media, e successivamente aggiornare con questa i parametri del modello.\n",
        "\n",
        "Ref:\n",
        "\n",
        "\n",
        "https://en.wikipedia.org/wiki/Stochastic_gradient_descent\n",
        "\n",
        "\n",
        "https://optimization.cbe.cornell.edu/index.php?title=Stochastic_gradient_descent\n",
        "\n",
        "$\\;$\n",
        "\n",
        "\n",
        "**Adaptive Moment Estimation** è un'estenzione del metodo SGD. Nello Stochastic Gradient Descent, il tasso di apprendimento, ovvero il learning rate (che regola la dimensione degli step compiuti durante l'aggiornamento dei parametri del modello), è un valore fisso. Questo valore rimane costante durante l'intero processo di apprendimento.\n",
        "\n",
        "Adam assegna invece un tasso di apprendimento adattivo ad ogni parametro del modello. Questi tassi vengono adattati dinamicamente durante l'allenamento in base a stime di momenti dei gradienti.\n",
        "\n",
        "Gli autori lo descrivono così: *The method computes individual adaptive learning rates for different parameters from estimates of first and second moments of the gradients*\n",
        "\n",
        "Grazie a questo adattamento, Adam può convergere più rapidamente verso la soluzione ottimale rispetto ad altri metodi. Svantaggi : in alcuni casi la generalizzazione delle prestazioni è peggiore di quella dell'SGD.\n",
        "\n",
        "Ref:\n",
        "\n",
        "\n",
        "https://optimization.cbe.cornell.edu/index.php?title=Adam\n"
      ],
      "metadata": {
        "id": "doeAJEVLiaHj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Optimizers in Tensorflow**\n",
        "\n",
        "Con il ternine Optimizer, si intente una tecnica (o algoritmo) che consente di adattare i parametri di un modello (rete neurale) in modo tale da ridurre al minimo il valore della funzione di loss. L'optimizer più semplice è la discesa del gradiente (Gradient Descent).\n",
        "\n",
        "TensorFlow fornisce diversi optimizer predefiniti tra cui scegliere. Questo si concretizza con una Classe che implementa una specifico algoritmo (Esempio: Adam, SGD, ...).\n",
        "\n",
        "Ref:\n",
        "\n",
        "https://www.tensorflow.org/guide/core/optimizers_core\n",
        "\n",
        "$\\;$\n",
        "\n",
        "**Accuracy: quanto spesso il modello produce un risultato corretto?**\n",
        "\n",
        "Accuracy è una metrica che misura la frequenza con cui un modello prevede correttamente il risultato atteso. Si puo calcolare l'accuracy dividendo il numero di previsioni corrette per il numero totale di previsioni effettuate.\n",
        "\n",
        "Ref:\n",
        "\n",
        "https://developers.google.com/machine-learning/crash-course/classification/accuracy\n",
        "\n",
        "\n",
        "$\\;$\n",
        "\n",
        "**Salvare e caricare i parametri del modello**\n",
        "\n",
        "Durante e dopo il training, è possibile salvare i parametri del modello.\n",
        "Questo offre due vantaggi:\n",
        "\n",
        "1. Ripresa da dove si era interrotto: Il modello può riprendere l'addestramento da un punto precedente, evitando di dover ricominciare da zero; risparmiando così del tempo.\n",
        "\n",
        "2. Condivisione del modello: I modelli salvati possono essere condivisi con altri, consentendo loro di ricreare il lavoro svolto e di utilizzarlo per le proprie ricerche o applicazioni.\n",
        "\n",
        "Ref:\n",
        "\n",
        "https://www.tensorflow.org/guide/saved_model?hl=it\n",
        "\n",
        "\n",
        "https://www.tensorflow.org/guide/checkpoint\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "dnOJc-hZAg7-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Training process"
      ],
      "metadata": {
        "id": "7yU-TXQpHLFe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Parametri\n",
        "\n",
        "#number of neurons in input layer\n",
        "num_input = 784\n",
        "\n",
        "#number of neurons in hidden layer 1\n",
        "num_hidden1 = 128\n",
        "\n",
        "#number of neurons in hidden layer 2\n",
        "num_hidden2 = 64\n",
        "\n",
        "#number of neurons in output layer\n",
        "num_output = 10\n",
        "\n",
        "n_layers = [num_input, num_hidden1, num_hidden2, num_output]\n",
        "\n",
        "\n",
        "num_iterations = 5_000"
      ],
      "metadata": {
        "id": "rc7NdtU2qxKG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rg = NN(n_layers)\n",
        "\n",
        "for i in range(num_iterations+1):\n",
        "\n",
        "    #Pesca random x  e y dal training_dataset\n",
        "    ri = np.random.randint(low=0, high=len(xtrain))\n",
        "    x = xtrain[ri]\n",
        "    x = tf.reshape(x, [1, -1])\n",
        "    y = label_train[ri]\n",
        "    rg.backward(x,y)\n",
        "\n",
        "    if (i > 0) and ( (i % (num_iterations/5)) == 0) :\n",
        "       print(\"\\nEpoca:\",i)\n",
        "       y_pred = rg.forward(x)\n",
        "       print(\"Loss:\", rg.loss(y,y_pred))\n",
        "\n",
        "print(\"\\nFine del training\")\n",
        "#print(rg.params)\n",
        "\n",
        "# Salva i parametri del modello\n",
        "checkpoint = tf.train.Checkpoint(var_list=rg.params)\n",
        "save=checkpoint.save('./training_checkpoints1')\n",
        "\n",
        "print(\"\\nModello salvato \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tS33i71623N0",
        "outputId": "2c368062-9e55-4fa9-c1fe-55a8573fb19a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Epoca: 1000\n",
            "Loss: tf.Tensor(0.13689, shape=(), dtype=float32)\n",
            "\n",
            "Epoca: 2000\n",
            "Loss: tf.Tensor(0.013412074, shape=(), dtype=float32)\n",
            "\n",
            "Epoca: 3000\n",
            "Loss: tf.Tensor(0.11908475, shape=(), dtype=float32)\n",
            "\n",
            "Epoca: 4000\n",
            "Loss: tf.Tensor(1.192093e-07, shape=(), dtype=float32)\n",
            "\n",
            "Epoca: 5000\n",
            "Loss: tf.Tensor(1.192093e-07, shape=(), dtype=float32)\n",
            "\n",
            "Fine del training\n",
            "\n",
            "Modello salvato \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Verifica il funzionamento di tf.train.load_checkpoint"
      ],
      "metadata": {
        "id": "YiN4QylsWCgt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#carica e vedi il contenuto\n",
        "reader= tf.train.load_checkpoint(save)\n",
        "\n",
        "shape_from_key = reader.get_variable_to_shape_map()\n",
        "dtype_from_key = reader.get_variable_to_dtype_map()\n",
        "\n",
        "#print(dtype_from_key)\n",
        "sorted(shape_from_key.keys())\n",
        "\n",
        "#Nota\n",
        "#in Colab i file sono scaricabili dall'icona a sinistra a forma di cartella, chiamata File"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "93710M1YU5C9",
        "outputId": "b17e266b-541f-4f47-cd2a-aa058675f415"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['_CHECKPOINTABLE_OBJECT_GRAPH',\n",
              " 'save_counter/.ATTRIBUTES/VARIABLE_VALUE',\n",
              " 'var_list/0/.ATTRIBUTES/VARIABLE_VALUE',\n",
              " 'var_list/1/.ATTRIBUTES/VARIABLE_VALUE',\n",
              " 'var_list/2/.ATTRIBUTES/VARIABLE_VALUE',\n",
              " 'var_list/3/.ATTRIBUTES/VARIABLE_VALUE',\n",
              " 'var_list/4/.ATTRIBUTES/VARIABLE_VALUE',\n",
              " 'var_list/5/.ATTRIBUTES/VARIABLE_VALUE']"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#verifica il contenuto\n",
        "ke = 'var_list/1/.ATTRIBUTES/VARIABLE_VALUE'\n",
        "f = reader.get_tensor(ke)\n",
        "\n",
        "x = tf.Variable(f,dtype=tf.dtypes.float32, name='b1')\n",
        "#print(x)\n",
        "#print(rg.params[1])\n",
        "\n",
        "print(rg.params[1] == x)\n",
        "print(type(rg.params[1]) == type(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NwoSU5BkVKA6",
        "outputId": "9a0ec4f3-4369-4487-9ced-0a712ec3c886"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True  True  True  True  True\n",
            "   True  True  True  True  True  True  True  True]], shape=(1, 128), dtype=bool)\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Istanzia una nuova rete neurale\n",
        "rk = NN(n_layers)\n",
        "\n",
        "#iserisci i parametri salvati in checkpoint\n",
        "rk.W1.assign( (reader.get_tensor('var_list/0/.ATTRIBUTES/VARIABLE_VALUE') ) )\n",
        "rk.b1.assign( (reader.get_tensor('var_list/1/.ATTRIBUTES/VARIABLE_VALUE') ) )\n",
        "\n",
        "rk.W2.assign( (reader.get_tensor('var_list/2/.ATTRIBUTES/VARIABLE_VALUE') ) )\n",
        "rk.b2.assign( (reader.get_tensor('var_list/3/.ATTRIBUTES/VARIABLE_VALUE') ) )\n",
        "\n",
        "rk.W3.assign( (reader.get_tensor('var_list/4/.ATTRIBUTES/VARIABLE_VALUE') ) )\n",
        "rk.b3.assign( (reader.get_tensor('var_list/5/.ATTRIBUTES/VARIABLE_VALUE') ) )\n",
        "#Per maggiori info su tf.Variable.assign() https://www.tensorflow.org/guide/variable?hl=it\n",
        "\n",
        "#Nota\n",
        "# usando l'istruzione sottostante da errore nella fase di training : ValueError: No gradients provided for any variable:\n",
        "#rk.b2 = tf.Variable(reader.get_tensor('var_list/3/.ATTRIBUTES/VARIABLE_VALUE'),dtype=tf.dtypes.float32,name='b2')\n",
        "\n",
        "#Verifica che il risultato è corretto conforntando le due reti\n",
        "for i in range(3):\n",
        "    #Pesca random x  e y dal training_dataset\n",
        "    ri = np.random.randint(low=0, high=len(xtest))\n",
        "    x = xtest[ri]\n",
        "    x = tf.reshape(x, [1, -1])\n",
        "    y = label_test[ri]\n",
        "    print(\"\")\n",
        "    print(rk.forward(x) == rg.forward(x))\n"
      ],
      "metadata": {
        "id": "-e3skh6_QJVS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2df0257a-1a7e-420b-8cbb-6853068883fd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "tf.Tensor([[ True  True  True  True  True  True  True  True  True  True]], shape=(1, 10), dtype=bool)\n",
            "\n",
            "tf.Tensor([[ True  True  True  True  True  True  True  True  True  True]], shape=(1, 10), dtype=bool)\n",
            "\n",
            "tf.Tensor([[ True  True  True  True  True  True  True  True  True  True]], shape=(1, 10), dtype=bool)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Proseguiamo il processo di training con nuovi step, partendo dagli ultimi dati salvati in checkpoint\n",
        "\n",
        "for i in range(2000):\n",
        "    #Pesca random x  e y dal training_dataset\n",
        "    ri = np.random.randint(low=0, high=len(xtrain))\n",
        "    x = xtrain[ri]\n",
        "    x = tf.reshape(x, [1, -1])\n",
        "    y = label_train[ri]\n",
        "    rk.backward(x,y)"
      ],
      "metadata": {
        "id": "BSWWD2aQfqpy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Verifica\n",
        "ri = np.random.randint(low=0, high=len(xtest))\n",
        "x = xtest[ri]\n",
        "x = tf.reshape(x, [1, -1])\n",
        "y = label_test[ri]\n",
        "\n",
        "print(rk.forward(x) == rg.forward(x))\n",
        "print(\"\")\n",
        "print(\"True label: \", y)\n",
        "print(\"MORE TRAIN:\", rk.forward(x).numpy().round(2))\n",
        "print(\"LESS TRAIN:\", rg.forward(x).numpy().round(2)) # questa è una rete addestrata con sole 300 iterazioni"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pZZd_766htlQ",
        "outputId": "c9a14adc-df37-4ea2-98e8-f21fd3549c3c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([[False False False False False False False False False False]], shape=(1, 10), dtype=bool)\n",
            "\n",
            "True label:  [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
            "MORE TRAIN: [[0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]]\n",
            "LESS TRAIN: [[0.16 0.09 0.01 0.04 0.02 0.06 0.29 0.21 0.06 0.05]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Testiamo il lavoro NN ottenuta"
      ],
      "metadata": {
        "id": "NZzbsnY6l156"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ri = np.random.randint(low=0, high=len(xtest))\n",
        "\n",
        "x = xtest[ri]\n",
        "\n",
        "xf = x.reshape(28, 28)\n",
        "plt.figure(figsize=[1, 1])\n",
        "plt.imshow(xf, cmap=plt.get_cmap('gray'))\n",
        "plt.show()\n",
        "\n",
        "x = tf.reshape(x, [1, -1])\n",
        "y = label_test[ri]\n",
        "yy = rg.forward(x)\n",
        "print(\"TrueLabel:  \",y)\n",
        "print(\"Previsione: \",yy.numpy().round(2))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 177
        },
        "id": "GnTKPxQdy1PJ",
        "outputId": "6a3c801d-f325-4d33-abd4-39b5db127e76"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 100x100 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TrueLabel:   [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n",
            "Previsione:  [[0.01 0.   0.04 0.   0.   0.   0.95 0.   0.   0.  ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rg.accuracy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7slEeCM1z8Zv",
        "outputId": "42c87095-28b4-4eeb-c4ae-d50dd345e79d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Accuracy su tutto il test dataset :', 0.8325)"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    }
  ]
}