Data Programming Course  Check-in [0c54dd1e72]

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Big Data e Big Problem\n",
    "Normalmente si può trovare come definizione di big data la seguente:\n",
    "\n",
    "    I dati sono troppo grandi per entrare in memoria/disco rigido\n",
    "    \n",
    "Esiste però un altro problema Big:\n",
    "\n",
    "    anche su dati piccoli, il mio modello potrebbe richiedere più\n",
    "    risorse di quelle a mia disposizione"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nei big data dobbiamo fare delle scelte\n",
    "\n",
    "Semplificando, ci sono 3 variabili nel nostro sistema:\n",
    "\n",
    "* il tempo che siamo disponibili ad aspettare\n",
    "* lo spazio su RAM che siamo disponibili ad allocare\n",
    "* l'ammontare di informazioni che vogliamo ottenere (statistical power)\n",
    "\n",
    "Tanto più ottimizziamo uno di questi parametri, tanto più ci rimettiamo negli altri due."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"./immagini/power_triangle.png\" width=\"400\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"./immagini/tradeoff_spazio_velocita.png\" width=\"600\"/>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Inoltre, vedremo poi, che tanto più ottimizzeremo il nostro codice, tanto più difficile sarà mantenerlo nel tempo.\n",
    "La comprensibilità del nostro codice ha un costo quantificabile!\n",
    "\n",
    "Questo schema non tiene conto anche di altri fattori:\n",
    "\n",
    "* il tradoff fra memoria su disco e su RAM\n",
    "* il tempo che serve all'analista per produrre il codice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## un problema di esempio - rinominare i file di una collezione audio\n",
    "\n",

   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "!rm -fR notebookfiles/fakeaudio\n",

   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",

   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "directory = \"./notebookfiles/fakeaudio/\"\n",
    "for basepath, listdir, listfiles in os.walk(directory):\n",
    "    for filename in listfiles:\n",
    "        new_filename = filename.lower()\n",
    "        os.rename(os.path.join(basepath, filename),\n",
    "                  os.path.join(basepath, new_filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",

   "source": [
    "!ls -lR notebookfiles/fakeaudio/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "qui però sto anche cambiando il nome a tutti i file che sono presenti nelle directory, anche se non sono dei file audio!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "!rm -fR notebookfiles/fakeaudio\n",

   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "directory = \"./notebookfiles/fakeaudio/\"\n",
    "for basepath, listdir, listfiles in os.walk(directory):\n",
    "    for filename in listfiles:\n",
    "        if filename.lower().endswith('mp3'):\n",
    "            new_filename = filename.lower()\n",
    "            os.rename(os.path.join(basepath, filename),\n",
    "                      os.path.join(basepath, new_filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",

   "source": [
    "!ls -lR notebookfiles/fakeaudio/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Queste sono tre operazioni fondalmentali per l'analisi dati:\n",
    "\n",
    "* iterazione lazy\n",
    "* map (ripeti un'operazione su tutti gli elementi)\n",
    "* filter (seleziona solo una parte degli elementi)\n",
    "\n",
    "altri tipi di operazioni che discuteremo saranno:\n",
    "\n",
    "* reduce (comporre insieme gli elementi)\n",
    "* functional programming\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterazione Lazy\n",
    "\n",
    "che cosa intendiamo con iterazione **lazy**?\n",
    "\n",
    "le operazioni non vengono compiute finchè il risultato non è richiesto!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In Python questa cosa è gestita da degli oggetti chiamati **iteratori**.\n",
    "\n",
    "Sono gli oggetti su cui faccio i cicli **for**.\n",
    "\n",
    "Un iteratore può essere percorso una volta sola!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Questo è controintuitivo: se provo a fare un ciclo for su di una lista, lo posso fare quante volte voglio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "for elemento in lista:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ma se provo a farlo su di un file, lo posso leggere una volta sola!\n",
    "\n",
    "Se volessi rileggerlo, dovrei aprirlo di nuovo!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "    for line in file:\n",
    "        print(repr(line))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python ce lo nasconde, ma in realtà ogni volta che iteriamo sulla lista lui crea un nuovo iteratore che scorre la lista e poi scompare.\n",
    "\n",
    "Possiamo farlo esplicitamente con il comando **iter**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sottolineare quando le iterazioni non necessitano di caricare l'intero dataset è importante perchè non è sempre vero.\n",
    "\n",
    "Supponiamo di voler calcolare tutte le combinazioni di elementi di una sequenza: non possiamo risolvere questo problema senza tenere in memoria l'intera sequenza!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Map\n",
    "\n",
    "Un tipo di operazione molto frequente sulle sequenze è il cosiddetto **mapping**, ovvero applicare una funzione a tutti gli elementi di una lista, uno alla volta ed indipendentemente dagli altri.\n",
    "\n",
    "Ad esempio, avendo una serie di numeri, potrei voler prendere il quadrato di ciascuno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "    \n",
    "print(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo può essere espresso in modo pi conciso con una *comprehension*, che è funzionalmente identica al ciclo visto prima, ma più sintetica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "quadrati = [x**2 for x in numeri]\n",
    "print(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "il concetto di **map** è un'astrazione di questo procedimento.\n",
    "\n",
    "Python fornisce una funzione, chiamata appunto **map**, che prende una funzione ed un iteratore e ritorna un iteratore i cui elementi sono il risultato dell'operazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "quadrati = map(quadrato, numeri)\n",
    "print(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "ricordiamoci che il risultato delle operazioni sugli iteratori, quando possibile, è a sua volta un iteratore!\n",
    "\n",
    "siamo noi che dobbiamo esplicitamente **concretizzare** l'iterazione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {

   "source": [
    "list(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ricordiamoci che l'iterazione è compiuta una volta sola, quindi se vogliamo il risultato dobbiamo salvarcelo alla prima concretizzazione!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {

   "source": [
    "list(quadrati)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Filter\n",
    "\n",
    "in modo simile il concetto di **filter** è piuttosto semplice: seleziono un sottoinsieme dei miei dati, generando un secondo iteratore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "\n",
    "print(positivi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "in modo simile all'operazione di **map**, anche l'operazione di **filter** ha un costrutto nel linguaggio tramite le *comprehension*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "positivi = [x for x in numeri if x>0]\n",
    "print(positivi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ed esattamente come prima, abbiamo una funzione che prende una funzione di filtro (che ci dice se l'elemento è accettabile o no) e la applica ad un operatore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "positivi = filter(is_positive, numeri)\n",
    "print(list(positivi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reduce\n",
    "\n",
    "questa operazione combina gli elementi di un iteratore in un elemento unico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "    \n",
    "print(totale)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "come per casi precedenti, esiste una funzione preesistente per effettuare le operazioni di riduzione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",

    "totale = reduce(somma, numeri, 0)\n",
    "print(totale)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo tipo di operazioni è così comune che ci sono una serie di operazioni predefinite:\n",
    "\n",
    "* **sum** per la somma\n",
    "* **min** e **max** per il minimo e massimo\n",
    "\n",
    "e così via"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "una tipica riduzione, che useremo molto, è la stima delle frequenze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {

    "numeri = [1, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4]\n",
    "Counter(numeri)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Una proprietà importante delle riduzioni è che i risultati si possono combinare: dati i conteggi su due serie, posso sommare insieme i due conteggi ed ottenere i conteggi totali fra le due serie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Map Reduce\n",
    "\n",
    "il famoso metodo MAP-REDUCE è una combinazione di queste idee:\n",
    "\n",
    "* prendo una sequenza, la divido in sottosequenze\n",
    "* invio le sequenze a diversi computer\n",
    "* compio una riduzione su ciascuna sottosequenza\n",
    "* raccolgo le sottosequenze e le combino insieme\n",
    "* tutto questo fatto in modo ricorsivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",