1-Hands-on_Python3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hands-on Python 3\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/paolodeangelis/AEM/blob/main/1-Hands-on_Python3.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variabili e matematica di base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Commenti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I commenti iniziano con il simbolo cancelletto `#`\n",
    "\n",
    "\"\"\"\n",
    "Per commenti lunghi più righe si scrivono aprendo\n",
    "e chiudendo la sezione di codice con 3 `\"`.\n",
    "Solitamente questo tipo do commenti è usato all'inizio di uno script\n",
    "o di una funzione/classe come documentazione (vd. docstring)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variabili scalari"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_variable = \"memorizza delle stringhe\"  # stringhe\n",
    "an_integer = 5  # numeri interi\n",
    "a_float = 2.0  # numeri reali (numeri con parte decimale)\n",
    "a_boolean = True  # booleani (può avere solo due valori `True` o `False`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python non ha problemi a fare operazioni con variabili di tipo misto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_var = an_integer + a_float\n",
    "type(new_var)  # la funzione `type` restituisce che tipo di variabile (o oggetto) è"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_var = int(new_var)  # le funzioni `int`, `float`, `bool` e  `str` convertono la\n",
    "# variabile nel rispettivo tipo\n",
    "type(new_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variabili \"array-like\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Liste (`list`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [\"può contenere di tutto\", 5, 2.0, True]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[0]  # restituisce il primo (0) elemento della lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[-2]  # restituisce il secondo elemento dalla fine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[1:4]  # porzione di lista (list slice):\n",
    "# restituisce parte della lista dal secondo (1) al quarto (3) elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NB: </b> \n",
    "\n",
    "Rispetto a MATLAB la numerazione degli elementi inizia da `0`, e per accedere alla fine di un array si usa gli interi negativi (`-1`, `-2`, `…`) invece che `end`, `end-1`, `…`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list.append(\"appende un nuovo elemento\")\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list.pop(2)  # restituisce e rimuove il terzo (2) elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[0] = \"cambia il primo elemento\"\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(a_list)  # la funzione `len` restituisce la lunghezza della lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dizionari `dictionaries`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict = {\n",
    "    \"key\": \"value\",\n",
    "    \"integer\": 5,\n",
    "    \"float\": 2.0,\n",
    "    \"boolean\": True,\n",
    "}  # Esattamente come un dizionario abbiamo -> parola: definizione\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[\"key\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[\"integer\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[\"key\"] = \"modifico una 'voce' del dizionario\"\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operazioni Matematiche"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 + 2  # Addizione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 - 2  # Sottrazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 * 2  # Moltiplicazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 / 2  # Divisione, ATTENZIONE: la divisione in vecchie versioni di python può restituire solo la parte intera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5.0 / 2.0  # La divisione tra numeri float restituisce il valore coretto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "In versioni di python precedenti alla 3.6 la divisione tra interi restituisce un intero corrispondete alla parte intera del quoziente\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5.0 // 2.0  # Divisione 'parte intera' restituisce solo la parte intera della divisione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5**2  # Esponenziale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 % 2  # Modulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(5 + 2) * 5 + 2  # Ordine delle operazioni (PEMDAS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operazioni Logiche"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False  # N.B. python è sensibile alle maiuscole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "python è sensibile alle maiuscole (case sensitive). \n",
    "    \n",
    "`True ≠ true`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 != 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 != 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 >= 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flusso del programma in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional statements: `if` `elif` `then`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10  # prova a cambiare il valore della variabile\n",
    "if x > 10:\n",
    "    print(\"x è maggiore di 10.\")\n",
    "elif x < 10:\n",
    "    print(\"x è minore di 10.\")\n",
    "else:\n",
    "    print(\"x è ugguale a 10.\")\n",
    "# `elif` e `else` sono opzionali"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "A differenza di altri linguaggi, **python semplifica molto la sintassi**, quando si scrive uno *statement* non è necessario aprire e chiudere parentesi (in C si usa la graffa `{…}`), ma è IMPORTANTE la tabulazione. Cioè a fine di uno statement si mettono sempre i due punti (`:`) e subito dopo le istruzioni da eseguire hanno una indentazione\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ciclo `for`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ungaretti = [\"M'\" \"illumino\\n\" \"d'\" \"immenso\"]\n",
    "poesia = \"\"\n",
    "for parola in ungaretti:\n",
    "    poesia += parola\n",
    "print(poesia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "L’operatore `+=`  (similmente `*=`, `/=`, `…`) «auto»-aggiunge un valore alla variabile.\n",
    "\n",
    "L’operatore addizione per le stringhe equivale a concatenarle\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(i)\n",
    "# range() inizia da 0 e conta fino a 3 (3 escluso)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = []\n",
    "for i in range(4, 10, 2):\n",
    "    a_list.append(i)\n",
    "# range() inizia da 4 e conta ogni 2 fino a 10 (10 escluso).\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ciclo `while`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while x < 3:\n",
    "    print(f\"{x:d} è minore di 3.\")  # Formattazione con il method `.format`\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 16\n",
    "while True:\n",
    "    x //= 2\n",
    "    if x > 1:\n",
    "        print(x)\n",
    "    else:\n",
    "        print(x, \"-> end\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "Il ciclo `while` è la principale causa di «loop infiniti» se non usato correttamente. Per fermare in anticipo un ciclo usa l’istruzione `break`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nidificazione (nesting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prime = []\n",
    "for i in range(1, 100):\n",
    "    is_prime = True\n",
    "    for p in prime:\n",
    "        if i % p == 0 and p != 1:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        prime.append(i)\n",
    "# N.B: Fa attenzione alle indentazioni di ogni blocco di codice\n",
    "print(prime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funzioni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_primes(n_max: int, display: bool = True) -> list:\n",
    "    \"\"\"Get the prime numbers from 1 to ``n_max``\n",
    "\n",
    "    Args:\n",
    "        n_max (int): the function search for all primes < ``n_max``.\n",
    "        display (bool, optional): if True, print a message with the found prime numbers. Defaults to True.\n",
    "\n",
    "    Raises:\n",
    "        AssertionError: if ``n_max`` is not an integer.\n",
    "        ValueError: if ``n_max`` is greater that 100000.\n",
    "\n",
    "    Returns:\n",
    "        list: the list with the found prime numbers\n",
    "    \"\"\"\n",
    "    # E' una buona pratica controllare che la funzione riceva input coretti\n",
    "    if not isinstance(n_max, int):\n",
    "        raise AssertionError(\n",
    "            f\"First argument must be an integer, instead we recive a {type(n_max)}\"\n",
    "        )\n",
    "    if n_max > 100000:\n",
    "        raise ValueError(f\"The first argument is too big ({n_max} > 100000)\")\n",
    "    prime = []\n",
    "    for i in range(1, n_max):\n",
    "        is_prime = True\n",
    "        for p in prime:\n",
    "            if i % p == 0 and p != 1:\n",
    "                is_prime = False\n",
    "                break\n",
    "        if is_prime:\n",
    "            prime.append(i)\n",
    "    if display:\n",
    "        print(f\"prime numbers < {n_max}:\")\n",
    "        print(\n",
    "            \" \".join([f\"{p}\" for p in prime])\n",
    "        )  # altra magia di python, cicli `for`` dentro una lista (qui usata per convertire i numeri in stringhe)\n",
    "    return prime  # senza l' instance `return` la funzione ritorna `None` (cioè niente)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con la funzione `help` stampiamo la documentazione della funzione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(get_primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eseguiamo la funzione:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_primes = get_primes(150, display=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cosa succede se passiamo un numero `float` alla funzione?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_primes(1e3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E se passiamo un numero troppo grande?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_primes(999999)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pausa\n",
    "\n",
    "<img src=\"https://github.com/paolodeangelis/AEM/raw/main/img/coffe_break.jpg\" width=\"400\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classi (a.k.a. Oggetti)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "In python **tutto è un oggetto**, infatti anche le variabili viste prima (int, float,…) o le funzioni, sono oggetti.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esempio definiamo l'oggetto `Student` che è una sotto-classe dell'oggetto `Person`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TODAY = \"03/05/2024\"\n",
    "\n",
    "\n",
    "class Person:\n",
    "    \"\"\"Person class define virtually a person.\n",
    "\n",
    "    We are not here to answer the philosophical question, \"What is a person?\".\n",
    "    Here a person is defined by the following attributes.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): Name of the person\n",
    "        family name (str): Family name of the person\n",
    "        age (int, optional): How old is the person\n",
    "        birthday (str, optional): The person's birthday\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, name: str, familyname: str, age: int = None, birthday: str = None\n",
    "    ):\n",
    "        \"\"\"Initialize the Person object.\n",
    "\n",
    "        The ``__init__`` method \"initialize\" the object, i.e., allocates a portion\n",
    "        of the memory (object construction). The ``__init__`` function is called every\n",
    "        time an object is created from a class.\n",
    "\n",
    "        Args:\n",
    "            name (str): Name of the person\n",
    "            family name (str): Family name of the person\n",
    "            age (int, optional): How old is the person. Defaults to None.\n",
    "            birthday (str, optional): The person's birthday. Defaults to None.\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.familyname = familyname\n",
    "        self.age = age\n",
    "        self.birthday = birthday\n",
    "\n",
    "    def _convert_date(\n",
    "        self, date: str\n",
    "    ):  # Quando un metodo inizia con \"_\" è considerato privato\n",
    "        for sep in [\" \", \"-\", \"\\\\\"]:\n",
    "            date = date.replace(sep, \"/\")\n",
    "        day, month, year = (int(s) for s in date.split(\"/\"))\n",
    "        return day + month * 30 + year * 30 * 12\n",
    "\n",
    "    def get_age(self):\n",
    "        if self.age is None:\n",
    "            age = round(\n",
    "                (self._convert_date(TODAY) - self._convert_date(self.birthday))\n",
    "                / (30 * 12)\n",
    "            )\n",
    "        else:\n",
    "            age = self.age\n",
    "        return age\n",
    "\n",
    "\n",
    "class Student(Person):\n",
    "    \"\"\"Student class defines virtually a student.\n",
    "\n",
    "    A student is a person with a \"matricola\".\n",
    "\n",
    "    Attributes:\n",
    "        name (str): Name of the person\n",
    "        family name (str): Family name of the person\n",
    "        matricola (int): Student identification number\n",
    "        age (int, optional): How old is the person\n",
    "        birthday (str, optional): The person's birthday\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        name: str,\n",
    "        familyname: str,\n",
    "        matricola: int,\n",
    "        age: int = None,\n",
    "        birthday: str = None,\n",
    "    ):\n",
    "        \"\"\"Initialize the Person object.\n",
    "\n",
    "        The ``__init__`` method \"initialize\" the object, i.e., allocates a portion\n",
    "        of the memory (object construction). The ``__init__`` function is called every\n",
    "        time an object is created from a class.\n",
    "\n",
    "        Args:\n",
    "            name (str): Name of the person\n",
    "            family name (str): Family name of the person\n",
    "            matricola (int): Student identification number\n",
    "            age (int, optional): How old is the person. Defaults to None.\n",
    "            birthday (str, optional): The person's birthday. Defaults to None.\n",
    "        \"\"\"\n",
    "        super().__init__(\n",
    "            name, familyname, age=age, birthday=birthday\n",
    "        )  # con `super()` richiama `__init__`` della classe Person\n",
    "        self.matricola = matricola\n",
    "        self.grade = None\n",
    "\n",
    "    def set_exam_grade(self, grade: int):\n",
    "        self.grade = grade\n",
    "\n",
    "    def exam_passed(self):\n",
    "        if self.grade is None:\n",
    "            print(f\"{self.name} {self.familyname} do the written exam first.\")\n",
    "        elif self.grade < 15:\n",
    "            print(\n",
    "                f\"{self.name} {self.familyname}, sorry but you fail the exam.\\nTry it again the next date.\"\n",
    "            )\n",
    "        elif self.grade < 18:\n",
    "            print(f\"Dear {self.name} {self.familyname}, you need to do the oral exam.\")\n",
    "        elif self.grade <= 30:\n",
    "            print(f\"Good job {self.name} {self.familyname}! you passed the exam!\")\n",
    "        else:\n",
    "            print(\n",
    "                f\"Good job {self.name} {self.familyname}! you passed the exam CUM LAUDE!\"\n",
    "            )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "Convezione nomi:\n",
    "-  `CONSTANTI` (tutto maiuscolo)\n",
    "-  `variabili` (tutto minuscolo)\n",
    "-  `funzioni` (tutto minuscolo solitamente inizia con un verbo in forma imperativa ex: get_something, do_something )\n",
    "-  `Oggetti` (prima lettera maiuscola)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Student)  # nota come non viene mostrato il metodo `_convert_date`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definisco lo stundete *Mario Rossi*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario = Student(\"Mario\", \"Rossi\", 271828, birthday=\"01/06/2000\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario.get_age()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario.set_exam_grade(28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario.exam_passed()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inputs/Outputs (I/O) in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aprimamo un file per salvare i dati di una traiettoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time = [i / 10 for i in range(5)]\n",
    "height = [-1 * (t**2) + t for t in time]\n",
    "\n",
    "file = open(\"a_file.txt\", \"w\")  # w: write, r: read, a:append\n",
    "file.write(\n",
    "    \"time[s]\".ljust(12, \" \") + \" \" + \"height[m]\".ljust(12, \" \") + \"\\n\"\n",
    ")  # Intestazione del file\n",
    "for t, y in zip(time, height):\n",
    "    file.write(f\"{t:<12.4e} {y:<12.4e}\" + \"\\n\")\n",
    "file.close()  # una volta aperto, un file va SEMPRE chiuso"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'è anche una modalità più compatta per scrivere un file, cioe usando un blocco *Contesto* che si definisce con `with`.\n",
    "\n",
    "Aprimao e *appendiamo* (`\"a\"`) nuovi dati della traiettoria sul file già creato."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time = [i / 10 for i in range(5, 11)]\n",
    "height = [-1 * (t**2) + t for t in time]\n",
    "\n",
    "with open(\"a_file.txt\", \"a\") as file:\n",
    "    for t, y in zip(time, height):\n",
    "        file.write(f\"{t:<12.4e} {y:<12.4e}\" + \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adesso proviamo ad aprire e leggere il file appena creato"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_r = []\n",
    "height_r = []\n",
    "\n",
    "with open(\"a_file.txt\") as file:\n",
    "    for i, line in enumerate(file):  # `enumerate` semplicemente conta i valori\n",
    "        if i == 0:\n",
    "            # la prima riga è l'intestazione che va ignorata\n",
    "            continue\n",
    "        line_splitted = line.split()\n",
    "        time_r.append(float(line_splitted[0]))\n",
    "        height_r.append(float(line_splitted[1]))\n",
    "\n",
    "print(time_r)\n",
    "print(height_r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pacchetti e moduli"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Installiamo (da [PiPy](https://pypi.org/) mediante [`pip`](https://pip.pypa.io/en/stable/)) le 4 librerie più utili in ambito scientifico/ingegneristico."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggiornamento di `pip` all'ultima versione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -m pip install --upgrade pip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Numpy](https://numpy.org/) \n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/NumPy_logo_2020.svg/1200px-NumPy_logo_2020.svg.png\" width=\"150\"/>\n",
    "\n",
    "NumPy è una libreria, utile per gestire grandi array multidimensionali e matrici, insieme ad una vasta collezione di funzioni matematiche di alto livello per operare su questi array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [SciPy](https://scipy.org/)\n",
    "<img src=\"https://scipy.org/images/logo.svg\" width=\"70\"/>\n",
    "\n",
    "SciPy è una libera fondamentale per il calcolo scientifico e tecnico. Contiene moduli per l'ottimizzazione, algebra lineare, integrazione, interpolazione, funzioni speciali, FFT, ecc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install scipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [pandas](https://pandas.pydata.org/)\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/e/ed/Pandas_logo.svg/1200px-Pandas_logo.svg.png\" width=\"150\"/>\n",
    "\n",
    "pandas è una libreria per la manipolazione e l'analisi dei dati. In particolare, offre strutture dati (`DataFrame`) e operazioni per manipolare tabelle numeriche e serie temporali."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [matplotlib](https://matplotlib.org/)\n",
    "<img src=\"https://matplotlib.org/_static/images/logo2.svg\" width=\"170\"/>\n",
    "\n",
    "Matplotlib è una libreria per il plottaggio e la sua estensione matematica numerica NumPy, SciPy. Fornisce un'API orientata agli oggetti per incorporare i grafici in applicazioni che utilizzano strumenti GUI di uso generale come Tkinter, wxPython, Qt o GTK. Ha anche un modulo pylab, progettata per assomigliare molto a quella di MATLAB, sebbene il suo uso sia scoraggiato.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy, SciPy e Matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np  # importo numpy\n",
    "from matplotlib import pyplot as plt  # importo la libreria per plottare\n",
    "from scipy.fft import fft, fftfreq  # importo i metodi di FFT\n",
    "from scipy.signal import (  # importo i metodi per l'analisi dei segnali\n",
    "    butter,\n",
    "    freqz,\n",
    "    lfilter,\n",
    ")\n",
    "\n",
    "plt.style.use(\"default\")\n",
    "\n",
    "SAMPLE_FREQ = 50e3  # [Hz] Frequenza di campionamento\n",
    "WAVE_FREQ = 1e3  # [Hz] Frequenza segnale\n",
    "NOISE_FREQ_1 = 8e3  # [Hz] Frequenza rumore 1\n",
    "NOISE_FREQ_2 = 10e3  # [Hz] Frequenza rumore 2\n",
    "\n",
    "\n",
    "t = np.arange(0, 8 / WAVE_FREQ, 1 / SAMPLE_FREQ)  # [s] intervallo di campionamento\n",
    "wave = 2.0 * np.sin(2 * np.pi * WAVE_FREQ * t)  # onda definita come A*sin(2*pi*f*t)\n",
    "noise = 1.0 * np.sin(2 * np.pi * NOISE_FREQ_1 * t) + 0.5 * np.sin(\n",
    "    2 * np.pi * NOISE_FREQ_2 * t\n",
    ")\n",
    "\n",
    "signal = wave + noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 5))\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.plot(t, signal, alpha=0.5, label=\"signal with noise\")\n",
    "    ax.plot(t, noise, label=\"noise\")\n",
    "    ax.plot(t, wave, linewidth=2, label=\"signal\")\n",
    "    ax.legend()\n",
    "    ax.set_xlabel(\"Time [s]\")\n",
    "    ax.set_ylabel(\"Amplitude [-]\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analisi del segnale nello spazio delle frequenze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "signal_fft = fft(signal)\n",
    "freq_fft = fftfreq(len(signal), 1.0 / SAMPLE_FREQ)\n",
    "\n",
    "# Filtro passa-basso (numerico)\n",
    "order = 10  # ordine del filtro\n",
    "cutoff = (\n",
    "    5e3  # frequnza di cutoff (i.e. la frequnza per cui il segnale vine ridotto di 3 dB)\n",
    ")\n",
    "nyq = 0.5 * SAMPLE_FREQ  # Nyquist frequency\n",
    "b, a = butter(order, cutoff / nyq, btype=\"low\", analog=False)\n",
    "# applico il filtro\n",
    "signal_filtred = lfilter(b, a, signal)  # spazio dei tempi\n",
    "signal_filtred_fft = fft(signal_filtred)  # spazio delle frequenze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualiziomo il risultato (spazio delle frequenze)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 8))\n",
    "\n",
    "# dati per il plot\n",
    "filter_freq, filter_amplitude = freqz(b, a, worN=8000)\n",
    "N = len(t)\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax1 = fig.add_subplot(211)\n",
    "    ax2 = fig.add_subplot(212)\n",
    "    ax1.plot(\n",
    "        0.5 * SAMPLE_FREQ * filter_freq / np.pi,\n",
    "        np.abs(filter_amplitude),\n",
    "        label=\"cutoff\",\n",
    "    )\n",
    "    ax1.axvline(cutoff, color=\"k\", linewidth=0.5, label=\"cutoff\")\n",
    "    # plot metà della della trrasformata che è simmetrica\n",
    "    ax2.plot(\n",
    "        freq_fft[: N // 2],\n",
    "        2.0 / N * np.abs(signal_fft)[: N // 2],\n",
    "        label=\"signal with noise\",\n",
    "    )\n",
    "    ax2.plot(\n",
    "        freq_fft[: N // 2],\n",
    "        2.0 / N * np.abs(signal_filtred_fft)[: N // 2],\n",
    "        label=\"signal flitred\",\n",
    "    )\n",
    "    ax2.set_xlabel(\"Frequency [Hz]\")\n",
    "    for ax in [ax1, ax2]:\n",
    "        ax.legend()\n",
    "        ax.set_ylabel(\"Intesity [-]\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualiziomo il risultato (spazio dei tempi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 5))\n",
    "\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.plot(t, signal, alpha=0.5, label=\"signal with noise\")\n",
    "    ax.plot(t, wave, label=\"source signal\")\n",
    "    ax.plot(t, signal_filtred, label=\"filtred signal\")\n",
    "    ax.legend()\n",
    "    ax.set_xlabel(\"Time [s]\")\n",
    "    ax.set_ylabel(\"Amplitude [-]\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio clustering fiore *Iris*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'esercizio consiste nel usare un metodo di *unsupervised clustering* (classificazione non-supervisionata) per riconoscere automaticamente la specie di *Iris*\n",
    "solo da delle lunghezze e larghezze dei petali e dei sepali.\n",
    "Per fare ciò dobbiamo:\n",
    "\n",
    "0. Installiamo `scikit-learn`\n",
    "1. Scaricare ed importare il dataset (`iris.csv`)\n",
    "2. Dare uno primo sguardo ai dati e vedere se è necessario \"pulirli\"\n",
    "3. Normalizzare i valori (vd. [Normalization (EN)](https://en.wikipedia.org/wiki/Normalization_(statistics)))\n",
    "4. Ridurre la dimensione con la [Analisi delle componenti principali](https://it.wikipedia.org/wiki/Analisi_delle_componenti_principali) (EN: Principal Component Analysis)\n",
    "5. Usare la il metodo di unsupervised clustering *Gaussian Mixture* (vd [Gaussian Mixture Models Explained\n",
    " (EN)](https://towardsdatascience.com/gaussian-mixture-models-explained-6986aaf5a95))\n",
    "\n",
    "![Le tre diverse sepcie di Iris](https://raw.githubusercontent.com/paolodeangelis/AEM/main/img/iris.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0. Installiamo la versione `1.0.2` di `scikit-learn`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install scikit-learn==1.0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Scarichiamo il database `iris.csv`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/paolodeangelis/AEM/main/data/iris.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importiamo con `pandas` il database usando il metodo `read_csv`\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NB: </b> \n",
    "\n",
    "csv = Comma-Separated Values (Valori Separati da Virgole)\n",
    "<br>\n",
    "È un formato file comune per il salvataggio di dati leggibile sia da un umano che da una macchina\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np  # importo numpy\n",
    "import pandas as pd  # importo pandas\n",
    "from matplotlib import pyplot as plt  # importo la libreria per plottare\n",
    "\n",
    "plt.style.use(\"default\")\n",
    "\n",
    "iris_data = pd.read_csv(\"iris.csv\")\n",
    "iris_data[\"species\"] = iris_data[\"species\"].astype(\"category\")\n",
    "iris_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Dare uno primo sguardo ai dati e vedere se è necessario \"pulirli\"\n",
    "\n",
    "Una prima cosa da fare e fare una veloce analisi dei dati e visualizzarli. \n",
    "Una buona metrica da vedere e la correlazione tra i vari dati."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(iris_data.corr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_corr = iris_data.corr(numeric_only=True)  # Pearson correlation coefficient\n",
    "# vd. https://it.wikipedia.org/wiki/Indice_di_correlazione_di_Pearson\n",
    "iris_corr.style.background_gradient(cmap=\"coolwarm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 6))\n",
    "\n",
    "data_axis = [\"petal_width\", \"petal_length\"]  # prova a cambiarli\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax = fig.add_subplot(111)\n",
    "    for label in iris_data[\"species\"].unique():\n",
    "        sub_set = iris_data.loc[\n",
    "            iris_data[\"species\"] == label\n",
    "        ]  # plotto ogni specie con colori diversi\n",
    "        ax.scatter(sub_set[data_axis[0]], sub_set[data_axis[1]], label=label)\n",
    "    ax.legend()\n",
    "    ax.set_xlabel(data_axis[0])\n",
    "    ax.set_ylabel(data_axis[1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Normalizzare i valori\n",
    "\n",
    "Ci sono varie metodologie, le principali sono:\n",
    "\n",
    "| Metodo | Formula    |\n",
    "| --- | --- |\n",
    "| Standardizzazione | $ \\dfrac{X-\\mu }{\\sigma }$ |\n",
    "| t di Student | $ \\dfrac{\\widehat{\\beta }-\\beta _{0}}{\\text{s.e.} ({\\widehat {\\beta }})}$ |\n",
    "| Min-max | $\\dfrac{X - X_{\\min }}{X_{\\max }- X_{\\min }}$ |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "X_raw = iris_data.iloc[:, :-1].values.astype(float)  # separiamo i dati...\n",
    "Y_raw = iris_data.iloc[:, -1].values.astype(str)  # ...dalle etichette\n",
    "\n",
    "normalizer = StandardScaler()\n",
    "X = normalizer.fit_transform(X_raw)\n",
    "\n",
    "# se tutto e andato bene la media dovrebbe essere 0 e la deviazione standard 1\n",
    "print(\"mean: \", X.mean(axis=0))\n",
    "print(\"std: \", X.std(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Ridurre la dimensione Principal Component Analysis (PCA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components=3)  # Prova a cambiare il numero di componenti (il massimo è 4)\n",
    "X_pca = pca.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 6))\n",
    "\n",
    "data_axis = [\"petal_width\", \"petal_length\"]  # prova a cambiarli\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax1 = fig.add_subplot(121)\n",
    "    ax2 = fig.add_subplot(122)\n",
    "    for label in iris_data[\"species\"].unique():\n",
    "        indexs = np.where(Y_raw == label)[0]\n",
    "        sub_set = iris_data.loc[\n",
    "            iris_data[\"species\"] == label\n",
    "        ]  # plotto ogni specie con colori diversi\n",
    "        ax1.scatter(sub_set[data_axis[0]], sub_set[data_axis[1]], label=label)\n",
    "        ax2.scatter(X_pca[indexs, 0], X_pca[indexs, 1], label=label)\n",
    "    ax1.legend()\n",
    "    ax1.set_xlabel(data_axis[0])\n",
    "    ax1.set_ylabel(data_axis[1])\n",
    "    ax2.set_xlabel(\"1st component\")\n",
    "    ax2.set_ylabel(\"2nd component\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Usare la il metodo di unsupervised clustering `GaussianMixture`  \n",
    "\n",
    "Assume che i dati di un cluster sono disposti con una probabiltà gaussiana (multidimensionale). Questo algoritmi assume che ci siano `n_components` = *numero di cluster* gaussiane e i vari paramentri ($\\mu$, $\\sigma$) che massimizza il [Maximum Likelihood Estimate (MLE)](https://en.wikipedia.org/wiki/Maximum_likelihood_estimation)\n",
    "\n",
    "![EM Clustering](https://upload.wikimedia.org/wikipedia/commons/6/69/EM_Clustering_of_Old_Faithful_data.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.mixture import GaussianMixture\n",
    "\n",
    "cluster_model = GaussianMixture(\n",
    "    n_components=3,  # Il numero di `Mixture` cioè di cluster da cercare\n",
    "    covariance_type=\"full\",  # Stima/calcolo della matrice di covarianza\n",
    ")\n",
    "# training\n",
    "cluster_model.fit(X_pca)\n",
    "Y_prediction = cluster_model.predict(X_pca)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Valutiamo il risultato del clustering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "prima in modo qualitativo plottando i cluster originali vs quelli predetti dal modello"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 6))\n",
    "\n",
    "data_axis = [\"petal_width\", \"petal_length\"]  # prova a cambiarli\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax1 = fig.add_subplot(121)\n",
    "    ax2 = fig.add_subplot(122)\n",
    "    for label in iris_data[\"species\"].unique():\n",
    "        indexs = np.where(Y_raw == label)[0]\n",
    "        sub_set = iris_data.loc[\n",
    "            iris_data[\"species\"] == label\n",
    "        ]  # plotto ogni specie con colori diversi\n",
    "        ax1.scatter(X_pca[indexs, 0], X_pca[indexs, 1], label=label)\n",
    "    for clust_id in np.unique(Y_prediction):\n",
    "        indexs = np.where(Y_prediction == clust_id)[0]\n",
    "        ax2.scatter(X_pca[indexs, 0], X_pca[indexs, 1], label=f\"cluster {clust_id}\")\n",
    "    for ax in [ax1, ax2]:\n",
    "        ax.legend()\n",
    "        ax.set_xlabel(\"1st component\")\n",
    "        ax.set_ylabel(\"2nd component\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poi valutiamo il modello in modo quantitativo.\n",
    "\n",
    "Per fare ciò dobbiamo usare una metrica che misura la bondà del nostro modello. \n",
    "Per gli algoritmi di clustering dobbiamo usare indipendete dalla permutazione delle etichette *labels* (`Y_raw`, `Y_prediction`)\n",
    "\n",
    "In questo esercizion usiamo una metrica abbastaza comune che la **Mutual Info Score** (IT: [Informazione mutua](https://it.wikipedia.org/wiki/Informazione_mutua))\n",
    "\n",
    "$\n",
    "MI(U,V) = \n",
    "\\sum_{i=1}^{|U|} \\sum_{j=1}^{|V|} \\frac{|U_i\\cap V_j|}{N} \\log\\frac{N|U_i \\cap V_j|}{|U_i||V_j|}\n",
    "$\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NB: </b> \n",
    "    \n",
    "Osserva come la misura della infomazione $I = |A|\\log(|A|) = p_{A}\\log(p_{A})$ \n",
    "assomiglia molto alla definzione di Gibbs dell'entropia usata in Maccanica Statistica $ S = k_{B} \\sum_i p_{i}\\log(p_{i}) $\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mutual_info_score\n",
    "\n",
    "mi_score = mutual_info_score(Y_raw, Y_prediction)\n",
    "print(f\"Mutual Information Score = {mi_score*100:1.2f} %\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FINE\n",
    "\n",
    "Sei arrivato alla fine e sei sopravvisuto, *python* non è così complicato no?\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<details>\n",
    "<b></b> \n",
    "\n",
    "<b><a href=\"https://youtu.be/uHgt8giw1LY\">📂 Soluzioni esercitazione ML </a></b> \n",
    "</div>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f56a962d3a7bb3c24c28e660b878abc8ea07b38e319e22d8208006d09eddbc70"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}